From 3ddb3cd14639cb6272cea0c82c645edb92bcf7d7 Mon Sep 17 00:00:00 2001 From: Tooru Fujisawa Date: Sat, 4 Apr 2015 15:05:35 +0900 Subject: [PATCH] Bug 1149015 - Part 4: Remove some use of expression closure from jstests js1_8_5/reflect-parse/. r=luke --- js/src/tests/js1_8_5/reflect-parse/Match.js | 2 +- .../js1_8_5/reflect-parse/PatternAsserts.js | 16 +- .../js1_8_5/reflect-parse/PatternBuilders.js | 355 ++++++++++++------ .../js1_8_5/reflect-parse/alternateBuilder.js | 6 +- .../js1_8_5/reflect-parse/basicBuilder.js | 94 ++--- .../reflect-parse/destructuring-assignment.js | 16 +- .../destructuring-function-parameters.js | 54 +-- .../destructuring-variable-declarations.js | 46 +-- 8 files changed, 368 insertions(+), 221 deletions(-) diff --git a/js/src/tests/js1_8_5/reflect-parse/Match.js b/js/src/tests/js1_8_5/reflect-parse/Match.js index 311eb224a672..38e3d676919a 100644 --- a/js/src/tests/js1_8_5/reflect-parse/Match.js +++ b/js/src/tests/js1_8_5/reflect-parse/Match.js @@ -36,7 +36,7 @@ var Match = } }, - toString: function() "[object Pattern]" + toString: () => "[object Pattern]" }; Pattern.ANY = new Pattern; diff --git a/js/src/tests/js1_8_5/reflect-parse/PatternAsserts.js b/js/src/tests/js1_8_5/reflect-parse/PatternAsserts.js index 7719954ac4f8..21060e575947 100644 --- a/js/src/tests/js1_8_5/reflect-parse/PatternAsserts.js +++ b/js/src/tests/js1_8_5/reflect-parse/PatternAsserts.js @@ -2,10 +2,18 @@ loadRelativeToScript('PatternBuilders.js'); -function localSrc(src) "(function(){ " + src + " })" -function localPatt(patt) program([exprStmt(funExpr(null, [], blockStmt([patt])))]) -function blockSrc(src) "(function(){ { " + src + " } })" -function blockPatt(patt) program([exprStmt(funExpr(null, [], blockStmt([blockStmt([patt])])))]) +function localSrc(src) { + return "(function(){ " + src + " })"; +} +function localPatt(patt) { + return program([exprStmt(funExpr(null, [], blockStmt([patt])))]); +} +function blockSrc(src) { + return "(function(){ { " + src + " } })"; +} +function blockPatt(patt) { + return program([exprStmt(funExpr(null, [], blockStmt([blockStmt([patt])])))]); +} function assertBlockStmt(src, patt) { blockPatt(patt).assert(Reflect.parse(blockSrc(src))); diff --git a/js/src/tests/js1_8_5/reflect-parse/PatternBuilders.js b/js/src/tests/js1_8_5/reflect-parse/PatternBuilders.js index c99e5bdaf9d2..30978b2a2d74 100644 --- a/js/src/tests/js1_8_5/reflect-parse/PatternBuilders.js +++ b/js/src/tests/js1_8_5/reflect-parse/PatternBuilders.js @@ -4,128 +4,259 @@ loadRelativeToScript('Match.js'); var { Pattern, MatchError } = Match; -function program(elts) Pattern({ type: "Program", body: elts }) -function exprStmt(expr) Pattern({ type: "ExpressionStatement", expression: expr }) -function throwStmt(expr) Pattern({ type: "ThrowStatement", argument: expr }) -function returnStmt(expr) Pattern({ type: "ReturnStatement", argument: expr }) -function yieldExpr(expr) Pattern({ type: "YieldExpression", argument: expr }) -function lit(val) Pattern({ type: "Literal", value: val }) -function comp(name) Pattern({ type: "ComputedName", name: name }) -function spread(val) Pattern({ type: "SpreadExpression", expression: val}) +function program(elts) { + return Pattern({ type: "Program", body: elts }); +} +function exprStmt(expr) { + return Pattern({ type: "ExpressionStatement", expression: expr }); +} +function throwStmt(expr) { + return Pattern({ type: "ThrowStatement", argument: expr }); +} +function returnStmt(expr) { + return Pattern({ type: "ReturnStatement", argument: expr }); +} +function yieldExpr(expr) { + return Pattern({ type: "YieldExpression", argument: expr }); +} +function lit(val) { + return Pattern({ type: "Literal", value: val }); +} +function comp(name) { + return Pattern({ type: "ComputedName", name: name }); +} +function spread(val) { + return Pattern({ type: "SpreadExpression", expression: val}); +} var thisExpr = Pattern({ type: "ThisExpression" }); -function funDecl(id, params, body, defaults=[], rest=null) Pattern( - { type: "FunctionDeclaration", - id: id, - params: params, - defaults: defaults, - body: body, - rest: rest, - generator: false }) -function genFunDecl(id, params, body) Pattern({ type: "FunctionDeclaration", - id: id, - params: params, - defaults: [], - body: body, - generator: true }) -function varDecl(decls) Pattern({ type: "VariableDeclaration", declarations: decls, kind: "var" }) -function letDecl(decls) Pattern({ type: "VariableDeclaration", declarations: decls, kind: "let" }) -function constDecl(decls) Pattern({ type: "VariableDeclaration", declarations: decls, kind: "const" }) -function ident(name) Pattern({ type: "Identifier", name: name }) -function dotExpr(obj, id) Pattern({ type: "MemberExpression", computed: false, object: obj, property: id }) -function memExpr(obj, id) Pattern({ type: "MemberExpression", computed: true, object: obj, property: id }) -function forStmt(init, test, update, body) Pattern({ type: "ForStatement", init: init, test: test, update: update, body: body }) -function forOfStmt(lhs, rhs, body) Pattern({ type: "ForOfStatement", left: lhs, right: rhs, body: body }) -function forInStmt(lhs, rhs, body) Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: false }) -function forEachInStmt(lhs, rhs, body) Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: true }) -function breakStmt(lab) Pattern({ type: "BreakStatement", label: lab }) -function continueStmt(lab) Pattern({ type: "ContinueStatement", label: lab }) -function blockStmt(body) Pattern({ type: "BlockStatement", body: body }) -function literal(val) Pattern({ type: "Literal", value: val }) -var emptyStmt = Pattern({ type: "EmptyStatement" }) -function ifStmt(test, cons, alt) Pattern({ type: "IfStatement", test: test, alternate: alt, consequent: cons }) -function labStmt(lab, stmt) Pattern({ type: "LabeledStatement", label: lab, body: stmt }) -function withStmt(obj, stmt) Pattern({ type: "WithStatement", object: obj, body: stmt }) -function whileStmt(test, stmt) Pattern({ type: "WhileStatement", test: test, body: stmt }) -function doStmt(stmt, test) Pattern({ type: "DoWhileStatement", test: test, body: stmt }) -function switchStmt(disc, cases) Pattern({ type: "SwitchStatement", discriminant: disc, cases: cases }) -function caseClause(test, stmts) Pattern({ type: "SwitchCase", test: test, consequent: stmts }) -function defaultClause(stmts) Pattern({ type: "SwitchCase", test: null, consequent: stmts }) -function catchClause(id, guard, body) Pattern({ type: "CatchClause", param: id, guard: guard, body: body }) -function tryStmt(body, guarded, unguarded, fin) Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handler: unguarded, finalizer: fin }) -function letStmt(head, body) Pattern({ type: "LetStatement", head: head, body: body }) +function funDecl(id, params, body, defaults=[], rest=null) { + return Pattern({ type: "FunctionDeclaration", + id: id, + params: params, + defaults: defaults, + body: body, + rest: rest, + generator: false }); +} +function genFunDecl(id, params, body) { + return Pattern({ type: "FunctionDeclaration", + id: id, + params: params, + defaults: [], + body: body, + generator: true }); +} +function varDecl(decls) { + return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "var" }); +} +function letDecl(decls) { + return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "let" }); +} +function constDecl(decls) { + return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "const" }); +} +function ident(name) { + return Pattern({ type: "Identifier", name: name }); +} +function dotExpr(obj, id) { + return Pattern({ type: "MemberExpression", computed: false, object: obj, property: id }); +} +function memExpr(obj, id) { + return Pattern({ type: "MemberExpression", computed: true, object: obj, property: id }); +} +function forStmt(init, test, update, body) { + return Pattern({ type: "ForStatement", init: init, test: test, update: update, body: body }); +} +function forOfStmt(lhs, rhs, body) { + return Pattern({ type: "ForOfStatement", left: lhs, right: rhs, body: body }); +} +function forInStmt(lhs, rhs, body) { + return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: false }); +} +function forEachInStmt(lhs, rhs, body) { + return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: true }); +} +function breakStmt(lab) { + return Pattern({ type: "BreakStatement", label: lab }); +} +function continueStmt(lab) { + return Pattern({ type: "ContinueStatement", label: lab }); +} +function blockStmt(body) { + return Pattern({ type: "BlockStatement", body: body }); +} +function literal(val) { + return Pattern({ type: "Literal", value: val }); +} +var emptyStmt = Pattern({ type: "EmptyStatement" }); +function ifStmt(test, cons, alt) { + return Pattern({ type: "IfStatement", test: test, alternate: alt, consequent: cons }); +} +function labStmt(lab, stmt) { + return Pattern({ type: "LabeledStatement", label: lab, body: stmt }); +} +function withStmt(obj, stmt) { + return Pattern({ type: "WithStatement", object: obj, body: stmt }); +} +function whileStmt(test, stmt) { + return Pattern({ type: "WhileStatement", test: test, body: stmt }); +} +function doStmt(stmt, test) { + return Pattern({ type: "DoWhileStatement", test: test, body: stmt }); +} +function switchStmt(disc, cases) { + return Pattern({ type: "SwitchStatement", discriminant: disc, cases: cases }); +} +function caseClause(test, stmts) { + return Pattern({ type: "SwitchCase", test: test, consequent: stmts }); +} +function defaultClause(stmts) { + return Pattern({ type: "SwitchCase", test: null, consequent: stmts }); +} +function catchClause(id, guard, body) { + return Pattern({ type: "CatchClause", param: id, guard: guard, body: body }); +} +function tryStmt(body, guarded, unguarded, fin) { + return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handler: unguarded, finalizer: fin }); +} +function letStmt(head, body) { + return Pattern({ type: "LetStatement", head: head, body: body }); +} -function classStmt(id, heritage, body) Pattern({ type: "ClassStatement", - name: id, - heritage: heritage, - body: body}) -function classExpr(id, heritage, body) Pattern({ type: "ClassExpression", - name: id, - heritage: heritage, - body: body}) -function classMethod(id, body, kind, static) Pattern({ type: "ClassMethod", - name: id, - body: body, - kind: kind, - static: static }) +function classStmt(id, heritage, body) { + return Pattern({ type: "ClassStatement", + name: id, + heritage: heritage, + body: body}); +} +function classExpr(id, heritage, body) { + return Pattern({ type: "ClassExpression", + name: id, + heritage: heritage, + body: body}); +} +function classMethod(id, body, kind, static) { + return Pattern({ type: "ClassMethod", + name: id, + body: body, + kind: kind, + static: static }); +} +function funExpr(id, args, body, gen) { + return Pattern({ type: "FunctionExpression", + id: id, + params: args, + body: body, + generator: false }); +} +function genFunExpr(id, args, body) { + return Pattern({ type: "FunctionExpression", + id: id, + params: args, + body: body, + generator: true }); +} +function arrowExpr(args, body) { + return Pattern({ type: "ArrowFunctionExpression", + params: args, + body: body }); +} -function funExpr(id, args, body, gen) Pattern({ type: "FunctionExpression", - id: id, - params: args, - body: body, - generator: false }) -function genFunExpr(id, args, body) Pattern({ type: "FunctionExpression", - id: id, - params: args, - body: body, - generator: true }) -function arrowExpr(args, body) Pattern({ type: "ArrowFunctionExpression", - params: args, - body: body }) +function unExpr(op, arg) { + return Pattern({ type: "UnaryExpression", operator: op, argument: arg }); +} +function binExpr(op, left, right) { + return Pattern({ type: "BinaryExpression", operator: op, left: left, right: right }); +} +function aExpr(op, left, right) { + return Pattern({ type: "AssignmentExpression", operator: op, left: left, right: right }); +} +function updExpr(op, arg, prefix) { + return Pattern({ type: "UpdateExpression", operator: op, argument: arg, prefix: prefix }); +} +function logExpr(op, left, right) { + return Pattern({ type: "LogicalExpression", operator: op, left: left, right: right }); +} -function unExpr(op, arg) Pattern({ type: "UnaryExpression", operator: op, argument: arg }) -function binExpr(op, left, right) Pattern({ type: "BinaryExpression", operator: op, left: left, right: right }) -function aExpr(op, left, right) Pattern({ type: "AssignmentExpression", operator: op, left: left, right: right }) -function updExpr(op, arg, prefix) Pattern({ type: "UpdateExpression", operator: op, argument: arg, prefix: prefix }) -function logExpr(op, left, right) Pattern({ type: "LogicalExpression", operator: op, left: left, right: right }) +function condExpr(test, cons, alt) { + return Pattern({ type: "ConditionalExpression", test: test, consequent: cons, alternate: alt }); +} +function seqExpr(exprs) { + return Pattern({ type: "SequenceExpression", expressions: exprs }); +} +function newExpr(callee, args) { + return Pattern({ type: "NewExpression", callee: callee, arguments: args }); +} +function callExpr(callee, args) { + return Pattern({ type: "CallExpression", callee: callee, arguments: args }); +} +function arrExpr(elts) { + return Pattern({ type: "ArrayExpression", elements: elts }); +} +function objExpr(elts) { + return Pattern({ type: "ObjectExpression", properties: elts }); +} +function computedName(elts) { + return Pattern({ type: "ComputedName", name: elts }); +} +function templateLit(elts) { + return Pattern({ type: "TemplateLiteral", elements: elts }); +} +function taggedTemplate(tagPart, templatePart) { + return Pattern({ type: "TaggedTemplate", callee: tagPart, arguments : templatePart }); +} +function template(raw, cooked, ...args) { + return Pattern([{ type: "CallSiteObject", raw: raw, cooked: cooked}, ...args]); +} -function condExpr(test, cons, alt) Pattern({ type: "ConditionalExpression", test: test, consequent: cons, alternate: alt }) -function seqExpr(exprs) Pattern({ type: "SequenceExpression", expressions: exprs }) -function newExpr(callee, args) Pattern({ type: "NewExpression", callee: callee, arguments: args }) -function callExpr(callee, args) Pattern({ type: "CallExpression", callee: callee, arguments: args }) -function arrExpr(elts) Pattern({ type: "ArrayExpression", elements: elts }) -function objExpr(elts) Pattern({ type: "ObjectExpression", properties: elts }) -function computedName(elts) Pattern({ type: "ComputedName", name: elts }) -function templateLit(elts) Pattern({ type: "TemplateLiteral", elements: elts }) -function taggedTemplate(tagPart, templatePart) Pattern({ type: "TaggedTemplate", callee: tagPart, - arguments : templatePart }) -function template(raw, cooked, ...args) Pattern([{ type: "CallSiteObject", raw: raw, cooked: -cooked}, ...args]) function compExpr(body, blocks, filter, style) { - if (style == "legacy" || !filter) - return Pattern({ type: "ComprehensionExpression", body, blocks, filter, style }); - else - return Pattern({ type: "ComprehensionExpression", body, blocks: blocks.concat(compIf(filter)), filter: null, style }); + if (style == "legacy" || !filter) + return Pattern({ type: "ComprehensionExpression", body, blocks, filter, style }); + else + return Pattern({ type: "ComprehensionExpression", body, blocks: blocks.concat(compIf(filter)), filter: null, style }); } function genExpr(body, blocks, filter, style) { - if (style == "legacy" || !filter) - return Pattern({ type: "GeneratorExpression", body, blocks, filter, style }); - else - return Pattern({ type: "GeneratorExpression", body, blocks: blocks.concat(compIf(filter)), filter: null, style }); + if (style == "legacy" || !filter) + return Pattern({ type: "GeneratorExpression", body, blocks, filter, style }); + else + return Pattern({ type: "GeneratorExpression", body, blocks: blocks.concat(compIf(filter)), filter: null, style }); +} +function graphExpr(idx, body) { + return Pattern({ type: "GraphExpression", index: idx, expression: body }); +} +function letExpr(head, body) { + return Pattern({ type: "LetExpression", head: head, body: body }); +} +function idxExpr(idx) { + return Pattern({ type: "GraphIndexExpression", index: idx }); } -function graphExpr(idx, body) Pattern({ type: "GraphExpression", index: idx, expression: body }) -function letExpr(head, body) Pattern({ type: "LetExpression", head: head, body: body }) -function idxExpr(idx) Pattern({ type: "GraphIndexExpression", index: idx }) -function compBlock(left, right) Pattern({ type: "ComprehensionBlock", left: left, right: right, each: false, of: false }) -function compEachBlock(left, right) Pattern({ type: "ComprehensionBlock", left: left, right: right, each: true, of: false }) -function compOfBlock(left, right) Pattern({ type: "ComprehensionBlock", left: left, right: right, each: false, of: true }) -function compIf(test) Pattern({ type: "ComprehensionIf", test: test }) +function compBlock(left, right) { + return Pattern({ type: "ComprehensionBlock", left: left, right: right, each: false, of: false }); +} +function compEachBlock(left, right) { + return Pattern({ type: "ComprehensionBlock", left: left, right: right, each: true, of: false }); +} +function compOfBlock(left, right) { + return Pattern({ type: "ComprehensionBlock", left: left, right: right, each: false, of: true }); +} +function compIf(test) { + return Pattern({ type: "ComprehensionIf", test: test }); +} -function arrPatt(elts) Pattern({ type: "ArrayPattern", elements: elts }) -function objPatt(elts) Pattern({ type: "ObjectPattern", properties: elts }) +function arrPatt(elts) { + return Pattern({ type: "ArrayPattern", elements: elts }); +} +function objPatt(elts) { + return Pattern({ type: "ObjectPattern", properties: elts }); +} -function assignElem(target, defaultExpr = null, targetIdent = typeof target == 'string' ? ident(target) : target) defaultExpr ? aExpr('=', targetIdent, defaultExpr) : targetIdent -function assignProp(property, target, defaultExpr = null, shorthand = !target, targetProp = target || ident(property)) Pattern({ - type: "Property", key: ident(property), shorthand, - value: defaultExpr ? aExpr('=', targetProp, defaultExpr) : targetProp }) +function assignElem(target, defaultExpr = null, targetIdent = typeof target == 'string' ? ident(target) : target) { + return defaultExpr ? aExpr('=', targetIdent, defaultExpr) : targetIdent; +} +function assignProp(property, target, defaultExpr = null, shorthand = !target, targetProp = target || ident(property)) { + return Pattern({ + type: "Property", key: ident(property), shorthand, + value: defaultExpr ? aExpr('=', targetProp, defaultExpr) : targetProp }); +} diff --git a/js/src/tests/js1_8_5/reflect-parse/alternateBuilder.js b/js/src/tests/js1_8_5/reflect-parse/alternateBuilder.js index 0d158d11c741..a5bf791783fb 100644 --- a/js/src/tests/js1_8_5/reflect-parse/alternateBuilder.js +++ b/js/src/tests/js1_8_5/reflect-parse/alternateBuilder.js @@ -49,7 +49,7 @@ return { literal: function(val) { return ["LiteralExpr", { value: val }]; }, - expressionStatement: function(expr) expr, + expressionStatement: expr => expr, conditionalExpression: function(test, cons, alt) { return ["ConditionalExpr", {}, test, cons, alt]; }, @@ -140,7 +140,7 @@ return { yieldExpression: reject, letExpression: reject, - emptyStatement: function() ["EmptyStmt", {}], + emptyStatement: () => ["EmptyStmt", {}], blockStatement: function(stmts) { stmts.unshift("BlockStmt", {}); return stmts; @@ -190,7 +190,7 @@ return { throwStatement: function(expr) { return ["ThrowStmt", {}, expr]; }, - debuggerStatement: function() ["DebuggerStmt", {}], + debuggerStatement: () => ["DebuggerStmt", {}], letStatement: reject, switchCase: function(expr, stmts) { if (expr) diff --git a/js/src/tests/js1_8_5/reflect-parse/basicBuilder.js b/js/src/tests/js1_8_5/reflect-parse/basicBuilder.js index cf484cc89b6d..a2bc120dabe9 100644 --- a/js/src/tests/js1_8_5/reflect-parse/basicBuilder.js +++ b/js/src/tests/js1_8_5/reflect-parse/basicBuilder.js @@ -2,62 +2,62 @@ function test() { // Builder tests -Pattern("program").match(Reflect.parse("42", {builder:{program:function()"program"}})); +Pattern("program").match(Reflect.parse("42", {builder:{program:() => "program"}})); -assertGlobalStmt("throw 42", 1, { throwStatement: function() 1 }); -assertGlobalStmt("for (;;);", 2, { forStatement: function() 2 }); -assertGlobalStmt("for (x in y);", 3, { forInStatement: function() 3 }); -assertGlobalStmt("{ }", 4, { blockStatement: function() 4 }); -assertGlobalStmt("foo: { }", 5, { labeledStatement: function() 5 }); -assertGlobalStmt("with (o) { }", 6, { withStatement: function() 6 }); -assertGlobalStmt("while (x) { }", 7, { whileStatement: function() 7 }); -assertGlobalStmt("do { } while(false);", 8, { doWhileStatement: function() 8 }); -assertGlobalStmt("switch (x) { }", 9, { switchStatement: function() 9 }); -assertGlobalStmt("try { } catch(e) { }", 10, { tryStatement: function() 10 }); -assertGlobalStmt(";", 11, { emptyStatement: function() 11 }); -assertGlobalStmt("debugger;", 12, { debuggerStatement: function() 12 }); -assertGlobalStmt("42;", 13, { expressionStatement: function() 13 }); -assertGlobalStmt("for (;;) break", forStmt(null, null, null, 14), { breakStatement: function() 14 }); -assertGlobalStmt("for (;;) continue", forStmt(null, null, null, 15), { continueStatement: function() 15 }); +assertGlobalStmt("throw 42", 1, { throwStatement: () => 1 }); +assertGlobalStmt("for (;;);", 2, { forStatement: () => 2 }); +assertGlobalStmt("for (x in y);", 3, { forInStatement: () => 3 }); +assertGlobalStmt("{ }", 4, { blockStatement: () => 4 }); +assertGlobalStmt("foo: { }", 5, { labeledStatement: () => 5 }); +assertGlobalStmt("with (o) { }", 6, { withStatement: () => 6 }); +assertGlobalStmt("while (x) { }", 7, { whileStatement: () => 7 }); +assertGlobalStmt("do { } while(false);", 8, { doWhileStatement: () => 8 }); +assertGlobalStmt("switch (x) { }", 9, { switchStatement: () => 9 }); +assertGlobalStmt("try { } catch(e) { }", 10, { tryStatement: () => 10 }); +assertGlobalStmt(";", 11, { emptyStatement: () => 11 }); +assertGlobalStmt("debugger;", 12, { debuggerStatement: () => 12 }); +assertGlobalStmt("42;", 13, { expressionStatement: () => 13 }); +assertGlobalStmt("for (;;) break", forStmt(null, null, null, 14), { breakStatement: () => 14 }); +assertGlobalStmt("for (;;) continue", forStmt(null, null, null, 15), { continueStatement: () => 15 }); -assertBlockDecl("var x", "var", { variableDeclaration: function(kind) kind }); -assertBlockDecl("let x", "let", { variableDeclaration: function(kind) kind }); -assertBlockDecl("const x = undefined", "const", { variableDeclaration: function(kind) kind }); -assertBlockDecl("function f() { }", "function", { functionDeclaration: function() "function" }); +assertBlockDecl("var x", "var", { variableDeclaration: kind => kind }); +assertBlockDecl("let x", "let", { variableDeclaration: kind => kind }); +assertBlockDecl("const x = undefined", "const", { variableDeclaration: kind => kind }); +assertBlockDecl("function f() { }", "function", { functionDeclaration: () => "function" }); -assertGlobalExpr("(x,y,z)", 1, { sequenceExpression: function() 1 }); -assertGlobalExpr("(x ? y : z)", 2, { conditionalExpression: function() 2 }); -assertGlobalExpr("x + y", 3, { binaryExpression: function() 3 }); -assertGlobalExpr("delete x", 4, { unaryExpression: function() 4 }); -assertGlobalExpr("x = y", 5, { assignmentExpression: function() 5 }); -assertGlobalExpr("x || y", 6, { logicalExpression: function() 6 }); -assertGlobalExpr("x++", 7, { updateExpression: function() 7 }); -assertGlobalExpr("new x", 8, { newExpression: function() 8 }); -assertGlobalExpr("x()", 9, { callExpression: function() 9 }); -assertGlobalExpr("x.y", 10, { memberExpression: function() 10 }); -assertGlobalExpr("(function() { })", 11, { functionExpression: function() 11 }); -assertGlobalExpr("[1,2,3]", 12, { arrayExpression: function() 12 }); -assertGlobalExpr("({ x: y })", 13, { objectExpression: function() 13 }); -assertGlobalExpr("this", 14, { thisExpression: function() 14 }); -assertGlobalExpr("[x for (x in y)]", 17, { comprehensionExpression: function() 17 }); -assertGlobalExpr("(x for (x in y))", 18, { generatorExpression: function() 18 }); -assertGlobalExpr("(function() { yield 42 })", genFunExpr(null, [], blockStmt([exprStmt(19)])), { yieldExpression: function() 19 }); -assertGlobalExpr("(let (x) x)", 20, { letExpression: function() 20 }); +assertGlobalExpr("(x,y,z)", 1, { sequenceExpression: () => 1 }); +assertGlobalExpr("(x ? y : z)", 2, { conditionalExpression: () => 2 }); +assertGlobalExpr("x + y", 3, { binaryExpression: () => 3 }); +assertGlobalExpr("delete x", 4, { unaryExpression: () => 4 }); +assertGlobalExpr("x = y", 5, { assignmentExpression: () => 5 }); +assertGlobalExpr("x || y", 6, { logicalExpression: () => 6 }); +assertGlobalExpr("x++", 7, { updateExpression: () => 7 }); +assertGlobalExpr("new x", 8, { newExpression: () => 8 }); +assertGlobalExpr("x()", 9, { callExpression: () => 9 }); +assertGlobalExpr("x.y", 10, { memberExpression: () => 10 }); +assertGlobalExpr("(function() { })", 11, { functionExpression: () => 11 }); +assertGlobalExpr("[1,2,3]", 12, { arrayExpression: () => 12 }); +assertGlobalExpr("({ x: y })", 13, { objectExpression: () => 13 }); +assertGlobalExpr("this", 14, { thisExpression: () => 14 }); +assertGlobalExpr("[x for (x in y)]", 17, { comprehensionExpression: () => 17 }); +assertGlobalExpr("(x for (x in y))", 18, { generatorExpression: () => 18 }); +assertGlobalExpr("(function() { yield 42 })", genFunExpr(null, [], blockStmt([exprStmt(19)])), { yieldExpression: () => 19 }); +assertGlobalExpr("(let (x) x)", 20, { letExpression: () => 20 }); -assertGlobalStmt("switch (x) { case y: }", switchStmt(ident("x"), [1]), { switchCase: function() 1 }); -assertGlobalStmt("try { } catch (e) { }", 2, { tryStatement: (function(b, g, u, f) u), catchClause: function() 2 }); -assertGlobalStmt("try { } catch (e if e instanceof A) { } catch (e if e instanceof B) { }", [2, 2], { tryStatement: (function(b, g, u, f) g), catchClause: function() 2 }); -assertGlobalStmt("try { } catch (e) { }", tryStmt(blockStmt([]), [], 2, null), { catchClause: function() 2 }); +assertGlobalStmt("switch (x) { case y: }", switchStmt(ident("x"), [1]), { switchCase: () => 1 }); +assertGlobalStmt("try { } catch (e) { }", 2, { tryStatement: (b, g, u, f) => u, catchClause: () => 2 }); +assertGlobalStmt("try { } catch (e if e instanceof A) { } catch (e if e instanceof B) { }", [2, 2], { tryStatement: (b, g, u, f) => g, catchClause: () => 2 }); +assertGlobalStmt("try { } catch (e) { }", tryStmt(blockStmt([]), [], 2, null), { catchClause: () => 2 }); assertGlobalStmt("try { } catch (e if e instanceof A) { } catch (e if e instanceof B) { }", tryStmt(blockStmt([]), [2, 2], null, null), - { catchClause: function() 2 }); + { catchClause: () => 2 }); assertGlobalExpr("[x for (y in z) for (x in y)]", compExpr(ident("x"), [3, 3], null, "legacy"), - { comprehensionBlock: function() 3 }); + { comprehensionBlock: () => 3 }); -assertGlobalExpr("({ x: y } = z)", aExpr("=", 1, ident("z")), { objectPattern: function() 1 }); -assertGlobalExpr("({ x: y } = z)", aExpr("=", objPatt([2]), ident("z")), { propertyPattern: function() 2 }); -assertGlobalExpr("[ x ] = y", aExpr("=", 3, ident("y")), { arrayPattern: function() 3 }); +assertGlobalExpr("({ x: y } = z)", aExpr("=", 1, ident("z")), { objectPattern: () => 1 }); +assertGlobalExpr("({ x: y } = z)", aExpr("=", objPatt([2]), ident("z")), { propertyPattern: () => 2 }); +assertGlobalExpr("[ x ] = y", aExpr("=", 3, ident("y")), { arrayPattern: () => 3 }); } diff --git a/js/src/tests/js1_8_5/reflect-parse/destructuring-assignment.js b/js/src/tests/js1_8_5/reflect-parse/destructuring-assignment.js index 7c4a5c8bf21e..cba4197ee912 100644 --- a/js/src/tests/js1_8_5/reflect-parse/destructuring-assignment.js +++ b/js/src/tests/js1_8_5/reflect-parse/destructuring-assignment.js @@ -4,8 +4,8 @@ function test() { // destructuring assignment function testAssignmentCombinations(makePattSrc, makePattPatt) { - var pattSrcs = makePatternCombinations(function(n) ("x" + n + " = 0"), makePattSrc); - var pattPatts = makePatternCombinations(function(n) (aExpr("=", ident("x" + n), lit(0))), makePattPatt); + var pattSrcs = makePatternCombinations(n => ("x" + n + " = 0"), makePattSrc); + var pattPatts = makePatternCombinations(n => (aExpr("=", ident("x" + n), lit(0))), makePattPatt); for (var i = 0; i < pattSrcs.length; i++) { var src = pattSrcs[i].join(","); @@ -20,12 +20,12 @@ function testAssignmentCombinations(makePattSrc, makePattPatt) { } } -testAssignmentCombinations(function (n) ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "} = 0"), - function (n) (aExpr("=", - objPatt([assignProp("a" + n, ident("x" + n)), - assignProp("b" + n, ident("y" + n)), - assignProp("c" + n, ident("z" + n))]), - lit(0)))); +testAssignmentCombinations(n => ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "} = 0"), + n => (aExpr("=", + objPatt([assignProp("a" + n, ident("x" + n)), + assignProp("b" + n, ident("y" + n)), + assignProp("c" + n, ident("z" + n))]), + lit(0)))); } diff --git a/js/src/tests/js1_8_5/reflect-parse/destructuring-function-parameters.js b/js/src/tests/js1_8_5/reflect-parse/destructuring-function-parameters.js index 8c9b1963f0f3..ff53018d2d40 100644 --- a/js/src/tests/js1_8_5/reflect-parse/destructuring-function-parameters.js +++ b/js/src/tests/js1_8_5/reflect-parse/destructuring-function-parameters.js @@ -1,45 +1,53 @@ // |reftest| skip-if(!xulRuntime.shell) function test() { +var JS_HAS_EXPR_CLOSURES = true; + function testParamPatternCombinations(makePattSrc, makePattPatt) { - var pattSrcs = makePatternCombinations(function(n) ("x" + n), makePattSrc); - var pattPatts = makePatternCombinations(function(n) (ident("x" + n)), makePattPatt); + var pattSrcs = makePatternCombinations(n => ("x" + n), makePattSrc); + var pattPatts = makePatternCombinations(n => (ident("x" + n)), makePattPatt); for (var i = 0; i < pattSrcs.length; i++) { - function makeSrc(body) ("(function(" + pattSrcs[i].join(",") + ") " + body + ")") - function makePatt(body) (funExpr(null, pattPatts[i], body)) + function makeSrc(body) { + return "(function(" + pattSrcs[i].join(",") + ") " + body + ")"; + } + function makePatt(body) { + return funExpr(null, pattPatts[i], body); + } // no upvars, block body assertExpr(makeSrc("{ }", makePatt(blockStmt([])))); // upvars, block body assertExpr(makeSrc("{ return [x1,x2,x3,x4,x5]; }"), makePatt(blockStmt([returnStmt(arrExpr([ident("x1"), ident("x2"), ident("x3"), ident("x4"), ident("x5")]))]))); - // no upvars, expression body - assertExpr(makeSrc("(0)"), makePatt(lit(0))); - // upvars, expression body - assertExpr(makeSrc("[x1,x2,x3,x4,x5]"), - makePatt(arrExpr([ident("x1"), ident("x2"), ident("x3"), ident("x4"), ident("x5")]))); + if (JS_HAS_EXPR_CLOSURES) { + // no upvars, expression body + assertExpr(makeSrc("(0)"), makePatt(lit(0))); + // upvars, expression body + assertExpr(makeSrc("[x1,x2,x3,x4,x5]"), + makePatt(arrExpr([ident("x1"), ident("x2"), ident("x3"), ident("x4"), ident("x5")]))); + } } } -testParamPatternCombinations(function(n) ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "}"), - function(n) (objPatt([assignProp("a" + n, ident("x" + n)), - assignProp("b" + n, ident("y" + n)), - assignProp("c" + n, ident("z" + n))]))); +testParamPatternCombinations(n => ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "}"), + n => (objPatt([assignProp("a" + n, ident("x" + n)), + assignProp("b" + n, ident("y" + n)), + assignProp("c" + n, ident("z" + n))]))); -testParamPatternCombinations(function(n) ("{a" + n + ":x" + n + " = 10," + "b" + n + ":y" + n + " = 10," + "c" + n + ":z" + n + " = 10}"), - function(n) (objPatt([assignProp("a" + n, ident("x" + n), lit(10)), - assignProp("b" + n, ident("y" + n), lit(10)), - assignProp("c" + n, ident("z" + n), lit(10))]))); +testParamPatternCombinations(n => ("{a" + n + ":x" + n + " = 10," + "b" + n + ":y" + n + " = 10," + "c" + n + ":z" + n + " = 10}"), + n => (objPatt([assignProp("a" + n, ident("x" + n), lit(10)), + assignProp("b" + n, ident("y" + n), lit(10)), + assignProp("c" + n, ident("z" + n), lit(10))]))); -testParamPatternCombinations(function(n) ("[x" + n + "," + "y" + n + "," + "z" + n + "]"), - function(n) (arrPatt([assignElem("x" + n), assignElem("y" + n), assignElem("z" + n)]))); +testParamPatternCombinations(n => ("[x" + n + "," + "y" + n + "," + "z" + n + "]"), + n => (arrPatt([assignElem("x" + n), assignElem("y" + n), assignElem("z" + n)]))); -testParamPatternCombinations(function(n) ("[a" + n + ", ..." + "b" + n + "]"), - function(n) (arrPatt([assignElem("a" + n), spread(ident("b" + n))]))); +testParamPatternCombinations(n => ("[a" + n + ", ..." + "b" + n + "]"), + n => (arrPatt([assignElem("a" + n), spread(ident("b" + n))]))); -testParamPatternCombinations(function(n) ("[a" + n + ", " + "b" + n + " = 10]"), - function(n) (arrPatt([assignElem("a" + n), assignElem("b" + n, lit(10))]))); +testParamPatternCombinations(n => ("[a" + n + ", " + "b" + n + " = 10]"), + n => (arrPatt([assignElem("a" + n), assignElem("b" + n, lit(10))]))); } diff --git a/js/src/tests/js1_8_5/reflect-parse/destructuring-variable-declarations.js b/js/src/tests/js1_8_5/reflect-parse/destructuring-variable-declarations.js index 7028b1ae2549..1c8afb71ac20 100644 --- a/js/src/tests/js1_8_5/reflect-parse/destructuring-variable-declarations.js +++ b/js/src/tests/js1_8_5/reflect-parse/destructuring-variable-declarations.js @@ -2,12 +2,12 @@ function test() { function testVarPatternCombinations(makePattSrc, makePattPatt) { - var pattSrcs = makePatternCombinations(function(n) ("x" + n), makePattSrc); - var pattPatts = makePatternCombinations(function(n) ({ id: ident("x" + n), init: null }), makePattPatt); + var pattSrcs = makePatternCombinations(n => ("x" + n), makePattSrc); + var pattPatts = makePatternCombinations(n => ({ id: ident("x" + n), init: null }), makePattPatt); // It's illegal to have uninitialized const declarations, so we need a // separate set of patterns and sources. - var constSrcs = makePatternCombinations(function(n) ("x" + n + " = undefined"), makePattSrc); - var constPatts = makePatternCombinations(function(n) ({ id: ident("x" + n), init: ident("undefined") }), makePattPatt); + var constSrcs = makePatternCombinations(n => ("x" + n + " = undefined"), makePattSrc); + var constPatts = makePatternCombinations(n => ({ id: ident("x" + n), init: ident("undefined") }), makePattPatt); for (var i = 0; i < pattSrcs.length; i++) { // variable declarations in blocks @@ -29,29 +29,29 @@ function testVarPatternCombinations(makePattSrc, makePattPatt) { } } -testVarPatternCombinations(function (n) ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "} = 0"), - function (n) ({ id: objPatt([assignProp("a" + n, ident("x" + n)), - assignProp("b" + n, ident("y" + n)), - assignProp("c" + n, ident("z" + n))]), - init: lit(0) })); +testVarPatternCombinations(n => ("{a" + n + ":x" + n + "," + "b" + n + ":y" + n + "," + "c" + n + ":z" + n + "} = 0"), + n => ({ id: objPatt([assignProp("a" + n, ident("x" + n)), + assignProp("b" + n, ident("y" + n)), + assignProp("c" + n, ident("z" + n))]), + init: lit(0) })); -testVarPatternCombinations(function (n) ("{a" + n + ":x" + n + " = 10," + "b" + n + ":y" + n + " = 10," + "c" + n + ":z" + n + " = 10} = 0"), - function (n) ({ id: objPatt([assignProp("a" + n, ident("x" + n), lit(10)), - assignProp("b" + n, ident("y" + n), lit(10)), - assignProp("c" + n, ident("z" + n), lit(10))]), - init: lit(0) })); +testVarPatternCombinations(n => ("{a" + n + ":x" + n + " = 10," + "b" + n + ":y" + n + " = 10," + "c" + n + ":z" + n + " = 10} = 0"), + n => ({ id: objPatt([assignProp("a" + n, ident("x" + n), lit(10)), + assignProp("b" + n, ident("y" + n), lit(10)), + assignProp("c" + n, ident("z" + n), lit(10))]), + init: lit(0) })); -testVarPatternCombinations(function(n) ("[x" + n + "," + "y" + n + "," + "z" + n + "] = 0"), - function(n) ({ id: arrPatt([assignElem("x" + n), assignElem("y" + n), assignElem("z" + n)]), - init: lit(0) })); +testVarPatternCombinations(n => ("[x" + n + "," + "y" + n + "," + "z" + n + "] = 0"), + n => ({ id: arrPatt([assignElem("x" + n), assignElem("y" + n), assignElem("z" + n)]), + init: lit(0) })); -testVarPatternCombinations(function(n) ("[a" + n + ", ..." + "b" + n + "] = 0"), - function(n) ({ id: arrPatt([assignElem("a" + n), spread(ident("b" + n))]), - init: lit(0) })); +testVarPatternCombinations(n => ("[a" + n + ", ..." + "b" + n + "] = 0"), + n => ({ id: arrPatt([assignElem("a" + n), spread(ident("b" + n))]), + init: lit(0) })); -testVarPatternCombinations(function(n) ("[a" + n + ", " + "b" + n + " = 10] = 0"), - function(n) ({ id: arrPatt([assignElem("a" + n), assignElem("b" + n, lit(10))]), - init: lit(0) })); +testVarPatternCombinations(n => ("[a" + n + ", " + "b" + n + " = 10] = 0"), + n => ({ id: arrPatt([assignElem("a" + n), assignElem("b" + n, lit(10))]), + init: lit(0) })); }