Issue 545: Code cleanup

mrennie · mrennie · commit 6d2082d07a78 · 2014-05-21T17:30:23.000-04:00
https://code.google.com/p/esprima/issues/detail?id=545
diff --git a/demo/collector.js b/demo/collector.js
@@ -58,7 +58,7 @@ function collectRegex() {
         }
 
         timerId = window.setTimeout(function () {
-            var code, result, occurrences, model, i, str;
+            var code, result, occurrences, model, i;
 
             if (typeof window.editor === 'undefined') {
                 code = document.getElementById('code').value;
diff --git a/demo/functiontrace.js b/demo/functiontrace.js
@@ -28,14 +28,12 @@
 (function (global) {
     'use strict';
 
-    var lookup;
-
     function id(i) {
         return document.getElementById(i);
     }
 
     function traceInstrument() {
-        var tracer, code, i, functionList, signature, pos;
+        var tracer, code, signature;
 
         if (typeof window.editor === 'undefined') {
             code = document.getElementById('code').value;
diff --git a/demo/validate.js b/demo/validate.js
@@ -8,7 +8,7 @@ function validate(delay) {
     }
 
     validateId = window.setTimeout(function () {
-        var code, result, syntax, errors, i, str;
+        var code, result, syntax, errors, i;
 
         if (typeof window.editor === 'undefined') {
             code = document.getElementById('editor').value;
diff --git a/esprima.js b/esprima.js
@@ -67,14 +67,12 @@ parseStatement: true, parseSourceElement: true */
         PropertyKind,
         Messages,
         Regex,
-        SyntaxTreeDelegate,
         source,
         strict,
         index,
         lineNumber,
         lineStart,
         length,
-        delegate,
         lookahead,
         state,
         extra;
@@ -347,7 +345,7 @@ parseStatement: true, parseSourceElement: true */
     // 7.4 Comments
 
     function addComment(type, value, start, end, loc) {
-        var comment, attacher;
+        var comment;
 
         assert(typeof start === 'number', 'Comment must have valid position');
 
@@ -1171,7 +1169,7 @@ parseStatement: true, parseSourceElement: true */
     }
 
     function scanRegExp() {
-        var start, body, flags, pattern, value;
+        var start, body, flags, value;
 
         lookahead = null;
         skipComment();
@@ -1366,7 +1364,7 @@ parseStatement: true, parseSourceElement: true */
     }
 
     function collectToken() {
-        var loc, token, range, value;
+        var loc, token, value;
 
         skipComment();
         loc = {
@@ -2715,7 +2713,7 @@ parseStatement: true, parseSourceElement: true */
     // 11.13 Assignment Operators
 
     function parseAssignmentExpression() {
-        var oldParenthesisCount, token, expr, right, params, list, startToken;
+        var oldParenthesisCount, token, expr, right, list, startToken;
 
         oldParenthesisCount = state.parenthesisCount;
 
@@ -3773,15 +3771,13 @@ parseStatement: true, parseSourceElement: true */
 
     function tokenize(code, options) {
         var toString,
-            token,
             tokens;
 
         toString = String;
         if (typeof code !== 'string' && !(code instanceof String)) {
             code = toString(code);
         }
 
-        delegate = SyntaxTreeDelegate;
         source = code;
         index = 0;
         lineNumber = (source.length > 0) ? 1 : 0;
@@ -3826,12 +3822,11 @@ parseStatement: true, parseSourceElement: true */
                 return extra.tokens;
             }
 
-            token = lex();
+            lex();
             while (lookahead.type !== Token.EOF) {
                 try {
-                    token = lex();
+                    lex();
                 } catch (lexError) {
-                    token = lookahead;
                     if (extra.errors) {
                         extra.errors.push(lexError);
                         // We have to break on the first error
@@ -3867,7 +3862,6 @@ parseStatement: true, parseSourceElement: true */
             code = toString(code);
         }
 
-        delegate = SyntaxTreeDelegate;
         source = code;
         index = 0;
         lineNumber = (source.length > 0) ? 1 : 0;
diff --git a/test/benchmarks.js b/test/benchmarks.js
@@ -201,7 +201,7 @@ if (typeof window !== 'undefined') {
             }
 
             function run() {
-                var el, test, source, benchmark;
+                var test, source, benchmark;
 
                 if (index >= suite.length) {
                     setText('total-time', (1000 * totalTime).toFixed(1) + ' ms \xb1 ' +
@@ -212,7 +212,6 @@ if (typeof window !== 'undefined') {
                 }
 
                 test = slug(suite[index]);
-                el = id(test);
                 source = window.data[test];
                 setText(test + '-time', 'Running...');
 
@@ -305,8 +304,7 @@ if (typeof window !== 'undefined') {
         }
 
         function runTests(tests) {
-            var index,
-                tree = [],
+            var tree = [],
                 totalTime = 0,
                 totalSize = 0,
                 totalRme = 0;
diff --git a/test/reflect.js b/test/reflect.js
@@ -19,12 +19,12 @@
 
 function testReflect(Reflect, Pattern) {
 
-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 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 }); }
 var thisExpr = Pattern({ type: "ThisExpression" });
 function funDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
                                              id: id,
@@ -34,7 +34,7 @@ function funDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration
                                              rest: null,
                                              generator: false,
                                              expression: false
-                                             }) }
+                                             }); }
 function genFunDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
                                                 id: id,
                                                 params: params,
@@ -43,32 +43,32 @@ function genFunDecl(id, params, body) { return Pattern({ type: "FunctionDeclarat
                                                 rest: null,
                                                 generator: false,
                                                 expression: false
-                                                }) }
-function declarator(id, init) { return Pattern({ type: "VariableDeclarator", id: id, init: init }) }
-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 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 declarator(id, init) { return Pattern({ type: "VariableDeclarator", id: id, init: init }); }
+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 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 }); }
 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) { if (guard) { return Pattern({ type: "GuardedCatchClause", param: id, guard: guard, body: body }) } else { return Pattern({ type: "CatchClause", param: id, body: body }) } }
-function tryStmt(body, guarded, catches, fin) { return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handlers: catches, finalizer: fin }) }
-function letStmt(head, body) { return Pattern({ type: "LetStatement", head: head, body: body }) }
+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) { if (guard) { return Pattern({ type: "GuardedCatchClause", param: id, guard: guard, body: body }) } else { return Pattern({ type: "CatchClause", param: id, body: body }); } }
+function tryStmt(body, guarded, catches, fin) { return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handlers: catches, finalizer: fin }); }
+function letStmt(head, body) { return Pattern({ type: "LetStatement", head: head, body: body }); }
 function funExpr(id, args, body, gen) { return Pattern({ type: "FunctionExpression",
                                                 id: id,
                                                 params: args,
@@ -77,7 +77,7 @@ function funExpr(id, args, body, gen) { return Pattern({ type: "FunctionExpressi
                                                 rest: null,
                                                 generator: false,
                                                 expression: false
-                                                }) }
+                                                }); }
 function genFunExpr(id, args, body) { return Pattern({ type: "FunctionExpression",
                                               id: id,
                                               params: args,
@@ -86,29 +86,29 @@ function genFunExpr(id, args, body) { return Pattern({ type: "FunctionExpression
                                               rest: null,
                                               generator: false,
                                               expression: false
-                                              }) }
-
-function unExpr(op, arg) { return Pattern({ type: "UnaryExpression", operator: op, argument: arg, prefix: true }) }
-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 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 objProp(key, value, kind) { return Pattern({ type: "Property", key: key, value: value, kind: kind }) }
-
-function arrPatt(elts) { return Pattern({ type: "ArrayPattern", elements: elts }) }
-function objPatt(elts) { return Pattern({ type: "ObjectPattern", properties: elts }) }
-
-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 unExpr(op, arg) { return Pattern({ type: "UnaryExpression", operator: op, argument: arg, prefix: true }); }
+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 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 objProp(key, value, kind) { return Pattern({ type: "Property", key: key, value: value, kind: kind }); }
+
+function arrPatt(elts) { return Pattern({ type: "ArrayPattern", elements: elts }); }
+function objPatt(elts) { return Pattern({ type: "ObjectPattern", properties: elts }); }
+
+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)));
@@ -271,10 +271,10 @@ assertExpr("(x ^= y)", aExpr("^=", ident("x"), ident("y")));
 assertExpr("(x &= y)", aExpr("&=", ident("x"), ident("y")));
 assertExpr("(x || y)", logExpr("||", ident("x"), ident("y")));
 assertExpr("(x && y)", logExpr("&&", ident("x"), ident("y")));
-assertExpr("(w || x || y || z)", logExpr("||", logExpr("||", logExpr("||", ident("w"), ident("x")), ident("y")), ident("z")))
+assertExpr("(w || x || y || z)", logExpr("||", logExpr("||", logExpr("||", ident("w"), ident("x")), ident("y")), ident("z")));
 assertExpr("(x ? y : z)", condExpr(ident("x"), ident("y"), ident("z")));
-assertExpr("(x,y)", seqExpr([ident("x"),ident("y")]))
-assertExpr("(x,y,z)", seqExpr([ident("x"),ident("y"),ident("z")]))
+assertExpr("(x,y)", seqExpr([ident("x"),ident("y")]));
+assertExpr("(x,y,z)", seqExpr([ident("x"),ident("y"),ident("z")]));
 assertExpr("(a,b,c,d,e,f,g)", seqExpr([ident("a"),ident("b"),ident("c"),ident("d"),ident("e"),ident("f"),ident("g")]));
 assertExpr("(new Object)", newExpr(ident("Object"), []));
 assertExpr("(new Object())", newExpr(ident("Object"), []));
diff --git a/test/runner.js b/test/runner.js
@@ -114,7 +114,7 @@ function hasAttachedComment(syntax) {
 
 function testParse(esprima, code, syntax) {
     'use strict';
-    var expected, tree, actual, options, StringObject, i, len, err;
+    var expected, tree, actual, options, StringObject, i, len;
 
     // alias, so that JSLint does not complain.
     StringObject = String;
@@ -274,7 +274,7 @@ function testError(esprima, code, exception) {
 
         try {
             if (tokenize) {
-                esprima.tokenize(code, options[i])
+                esprima.tokenize(code, options[i]);
             } else {
                 esprima.parse(code, options[i]);
             }
@@ -342,9 +342,7 @@ if (typeof window !== 'undefined') {
             fixture,
             source,
             tick,
-            expected,
-            index,
-            len;
+            expected;
 
         function setText(el, str) {
             if (typeof el.innerText === 'string') {
diff --git a/test/test.js b/test/test.js
@@ -21010,14 +21010,6 @@ var testFixture = {
             message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
         },
 
-        // strict mode, using eval when IsSimpleParameterList is false
-        '"use strict"; (eval, a) => 42': {
-            index: 29,
-            lineNumber: 1,
-            column: 30,
-            message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
-        },
-
         '(a, a) => 42': {
             index: 6,
             lineNumber: 1,

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ function collectRegex() {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`timerId = window.setTimeout(function () {`
`61`		`- var code, result, occurrences, model, i, str;`
	`61`	`+ var code, result, occurrences, model, i;`
`62`	`62`
`63`	`63`	`if (typeof window.editor === 'undefined') {`
`64`	`64`	`code = document.getElementById('code').value;`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ function validate(delay) {`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`validateId = window.setTimeout(function () {`
`11`		`- var code, result, syntax, errors, i, str;`
	`11`	`+ var code, result, syntax, errors, i;`
`12`	`12`
`13`	`13`	`if (typeof window.editor === 'undefined') {`
`14`	`14`	`code = document.getElementById('editor').value;`