Issue 4353 - Remove non standard for each syntax

scripts/astDecompile.js

 let global = this;
 function decompileAST(ast) {
   let func = global["decompile" + ast.type];
   if (!func)
     throw "Unknown type " + ast.type;
   return func(ast);
 }
 
 function decompileProgram(ast) {
-  return [decompileAST(stmt) for each (stmt in ast.body)].join('\n');
+  return ast.body.map(decompileAST).join('\n');
 }
 
 /* Statements */
 function decompileEmptyStatement(ast) {
   return ";"
 }
 function decompileBlockStatement(ast) {
-  return '{\n' + [decompileAST(stmt) for each (stmt in ast.body)].join('\n') +
-    '\n}\n';
+  return '{\n' + ast.body.map(decompileAST).join('\n') + '\n}\n';
 }
 
 function decompileExpressionStatement(ast) {
   return decompileAST(ast.expression) + ";";
 }
 
 function decompileIfStatement(ast) {
   let str = "if (" + decompileAST(ast.test) + ")\n";
   str += decompileAST(ast.consequent);
   if (ast.alternate)
@@ skipping 13 matching lines @@
   return "continue" + (ast.label ? " " + ast.label.name : "") + ";";
 }
 
 function decompileWithStatement(ast) {
   return "with (" + decompileAST(ast.object) + ") " + decompileAST(ast.body);
 }
 
 function decompileSwitchStatement(ast) {
   let str = "switch (" + decompileAST(ast.discriminant) + ") {\n";
   let cases = [];
-  for each (let scase in ast.cases) {
+  for (let scase of ast.cases) {
     let casestr = scase.test ? "case " + decompileAST(scase.test) : "default";
     casestr += ":\n";
-    casestr += [decompileAST(stmt) for each (stmt in scase.consequent)]
-      .join('\n');
+    casestr += scase.consequent.map(decompileAST).join('\n');
     cases.push(casestr);
   }
   str += cases.join('\n') + '\n}\n';
   return str;
 }
 
 function decompileReturnStatement(ast) {
   return "return" + (ast.argument ? " " + decompileAST(ast.argument) :
       "") + ";";
 }
 
 function decompileThrowStatement(ast) {
   return "throw " + decompileAST(ast.argument) + ";";
 }
 
 function decompileTryStatement(ast) {
   let str = "try " + decompileAST(ast.block);
 
   let handlers = [];
   if (ast.handler && "type" in ast.handler)
     handlers.push(ast.handler);
   else if (ast.handlers)
     handlers = ast.handlers;
 
   let handler_strs = [];
-  for each (let handler in handlers) {
+  for (let handler of handlers) {
     let handler_str = "catch (" + decompileAST(handler.param);
     if (handler.guard)
       handler_str += " if " + decompileAST(handler.guard);
     handler_str += ") " + decompileAST(handler.body);
     handler_strs.push(handler_str);
   }
   str += handler_strs.join("");
   if (ast.finalizer)
     str += " finally " + decompileAST(ast.finalizer);
   return str;
@@ skipping 46 matching lines @@
       str += decompileVariableDeclaration(ast.left, true);
   else
       str += decompileAST(ast.left);
   str += " of " + decompileExpr(ast.right, ast) + ") ";
   str += decompileAST(ast.body);
   return str;
 }
 
 function decompileLetStatement(ast) {
   let str = "let (";
-  str += [d ? decompileAST(d) : ' ' for each (d in ast.head)].join(', ');
+  str += ast.head.map(d => d ? decompileAST(d) : ' ').join(', ');
   str += ") " + decompileAST(ast.body);
   return str;
 }
 
 function decompileDebuggerStatement(ast) {
   return "debugger;";
 }
 
 function decompileFunctionDeclaration(ast, init, name_ast) {
   let str = (init ? init : "function") + " ";
   if (ast.id)
     str += ast.id.name;
   else if (name_ast)
     str += decompileAST(name_ast);
   str += "(";
-  str += [decompileAST(param) for each (param in ast.params)].join(', ');
+  str += ast.params.map(decompileAST).join(', ');
   str += ") " + decompileAST(ast.body);
   return str;
 }
 
 function decompileVariableDeclaration(ast, excludeSemi) {
   let inits = [];
-  for each (let initializer in ast.declarations) {
+  for (let initializer of ast.declarations) {
     inits.push(decompileAST(initializer));
   }
   return ast.kind + " " + inits.join(', ') + (excludeSemi ? "" : ";");
 }
 
 function decompileVariableDeclarator(ast) {
   if (ast.init)
     return decompileAST(ast.id) + " = " + decompileAST(ast.init);
   return decompileAST(ast.id);
 }
@@ skipping 36 matching lines @@
   else
     return decompileAST(expr);
 }
 
 function decompileThisExpression(ast) {
     return "this";
 }
 
 function decompileArrayExpression(ast) {
   if (ast.elements)
-    return "[" + [el ? decompileAST(el) : "" for each (el in ast.elements)].
+    return "[" + ast.elements.map(el => el ? decompileAST(el) : "").
       join(", ") + "]";
   return "[]";
 }
 
 function decompileObjectExpression(ast) {
   let props = [];
-  for each (let prop in ast.properties) {
+  for (let prop of ast.properties) {
     if (prop.kind == "init")
       props.push(decompileAST(prop.key) + ": " + decompileAST(prop.value));
     else if (prop.kind == "get" || prop.kind == "set")
       props.push(decompileFunctionDeclaration(prop.value, prop.kind, prop.key));
     else
       throw "Unknown kind " + prop.kind;
   }
   return "{\n" + props.join(",\n") + "}";
 }
 
 function decompileFunctionExpression(ast) {
   return decompileFunctionDeclaration(ast);
 }
 
 function decompileArrowExpression(ast) {
   let str = "(" + ast.params.map(decompileAST).join(", ") + ")";
   str += " => " + decompileAST(ast.body);
   return str;
 }
 
 function decompileSequenceExpression(ast) {
-  return "(" + [decompileExpr(e, ast) for each (e in ast.expressions)].join(", ") + ")";
+  return "(" + ast.expressions.map(e => decompileExpr(e, ast)).join(", ") + ")";
 }
 
 function decompileUnaryExpression(ast) {
   if (ast.prefix)
     return ast.operator + " " + decompileExpr(ast.argument, ast);
   throw "ER, wtf?";
 }
 
 function decompileBinaryExpression(ast) {
   return decompileExpr(ast.left, ast) + " " + ast.operator +
@@ skipping 21 matching lines @@
 
 function decompileConditionalExpression(ast) {
   return decompileExpr(ast.test, ast) + " ? " +
     decompileExpr(ast.consequent, ast) + " : " +
     decompileExpr(ast.alternate, ast);
 }
 
 function decompileNewExpression(ast) {
   let str = "new " + decompileAST(ast.callee, ast) + "(";
   if (ast.arguments)
-    str += [decompileAST(arg) for each (arg in ast.arguments)].join(", ");
+    str += ast.arguments.map(decompileAST).join(", ");
   str += ")";
   return str;
 }
 
 function decompileCallExpression(ast) {
   return decompileExpr(ast.callee, ast) + "(" +
-    [decompileAST(param) for each (param in ast.arguments)] + ")";
+    ast.arguments.map(decompileAST) + ")";
 }
 
 function decompileMemberExpression(ast) {
   function isIdentifier(ast2) {
     let val = decompileAST(ast2);
     if (val.length == 0) return false;
     if (!(val[0] == '_' || val[0] == '$' ||
           (val[0] >= 'a' && val[0] <= 'z') || (val[0] >= 'A' && val[0] <= 'Z')))
         return false;
     for (let i = 1; i < val.length; i++) {
@@ skipping 11 matching lines @@
        '["' + sanitize(decompileAST(ast.property), '"') + '"]' :
        '.' + ast.property.name);
 }
 
 function decompileYieldExpression(ast) {
   return "yield" + (ast.argument ? " " + decompileAST(ast.argument) : "");
 }
 
 function decompileComprehensionExpression(ast, paren) {
   let str = (paren ? paren.l : "[") + decompileAST(ast.body);
-  for each (let block in ast.blocks) {
-    str += (block.each ? " for each " : " for ")
+  for (let block of ast.blocks) {
+    str += (block.each ? " for each " : " for ");
     str += "(" + decompileAST(block.left) + " in ";
     str += decompileAST(block.right) + ")";
   }
   if (ast.filter)
     str += " if (" + decompileAST(ast.filter) + ")";
   return str + (paren ? paren.r : "]");
 }
 
 function decompileGeneratorExpression(ast) {
   return decompileComprehensionExpression(ast, {l: "(", r: ")"});
 }
 
 function decompileGraphExpression(ast) {
   return "#" + ast.index + "=" + decompileAST(ast.expression);
 }
 
 function decompileGraphIndexExpression(ast) {
   return "#" + ast.index;
 }
 
 function decompileLetExpression(ast) {
   return decompileLetStatement(ast);
 }
 
 /* Patterns */
 
 function decompileObjectPattern(ast) {
   let str = "{";
-  str += [decompileAST(p.key) + ": " + decompileAST(p.value)
-    for each (p in ast.properties)].join(', ');
+  str += ast.properties.map(p => decompileAST(p.key) + ": " +
+                                 decompileAST(p.value)).join(', ');
   return str + "}";
 }
 
 function decompileArrayPattern(ast) {
-  return "[" +
-    [e ? decompileAST(e) : ' ' for each (e in ast.elements)].join(', ') + "]";
+  return "[" + ast.elements.map(e => e ? decompileAST(e) : ' ').join(', ') + "]";
 }
 
 function decompileIdentifier(ast) { return ast.name; }
 
 function sanitize(str, q) {
   function replace(x) {
     if (x == q) return '\\' + q;
     if (x == '\\') return '\\\\';
     if (x == '\b') return '\\b';
     if (x == '\f') return '\\f';
     if (x == '\n') return '\\n';
     if (x == '\r') return '\\r';
     if (x == '\t') return '\\t';
     if (x == '\v') return '\\v';
-    let val = x.charCodeAt(0)
+    let val = x.charCodeAt(0);
     if (x < ' ') return '\\x' + (val - val % 16) / 16 + (val % 16);
     return x;
   }
-  return [replace(x) for each (x in str)].join('');
+  let result = "";
+  for (let char of str)
+    result += replace(char);
+  return result;
 }
 
 function decompileLiteral(ast) {
   if (typeof ast.value == "string")
     return '"' + sanitize(ast.value, '"') + '"';
   if (ast.value === null)
       return "null";
   return ast.value;
 }
 
@@ skipping 28 matching lines @@
 
 function decompileXMLAttributeSelector(ast) {
   return "@" + decompileAST(ast.attribute);
 }
 
 function decompileXMLFilterExpression(ast) {
   return decompileAST(ast.left) + ".(" + decompileAST(ast.right) + ")";
 }
 
 function decompileXMLElement(ast) {
-  return [decompileAST(xml) for each (xml in ast.contents)].join('');
+  return  ast.contents.map(decompileAST).join('');
 }
 
 function decompileXMLList(ast) {
-  return "<>" + [decompileAST(xml) for each (xml in ast.contents)].join("") + "</>";
+  return "<>" +   ast.contents.map(decompileAST).join("") + "</>";

[Wladimir Palant, 2016/08/24 14:21:50]

Nit: You've added unnecessary whitespace here.

[kzar, 2016/08/24 14:43:20]

Done.

 }
 
 function decompileXMLEscape(ast) {
   return "{" + decompileAST(ast.expression) + "}";
 }
 
 function decompileXMLText(ast) {
   return ast.text;
 }
 
 function tagJoin(strings) {
   let str = strings[0];
   for (let i = 1; i < strings.length; i++)
     str += (i % 2 ? ' ' : '=') + strings[i];
   return str;
 }
 
 function decompileXMLStartTag(ast) {
-  return "<" + tagJoin([decompileAST(xml) for each (xml in ast.contents)]) + ">";
+  return "<" + tagJoin(ast.contents.map(decompileAST)) + ">";
 }
 
 function decompileXMLEndTag(ast) {
-  return "</" + tagJoin([decompileAST(xml) for each (xml in ast.contents)]) + ">";
+  return "</" + tagJoin(ast.contents.map(decompileAST)) + ">";
 }
 
 function decompileXMLPointTag(ast) {
-  return "<" + tagJoin([decompileAST(xml) for each (xml in ast.contents)]) + "/>";
+  return "<" + tagJoin(ast.contents.map(decompileAST)) + "/>";
 }
 
 function decompileXMLName(ast) {
   if (typeof ast.contents == "string")
     return ast.contents + " ";
-  return [decompileAST(xml) for each (xml in ast.contents)].join('');
+  return ast.contents.map(decompileAST).join('');
 }
 
 function decompileXMLAttribute(ast) {
   return '"' + ast.value + '"';
 }
 
 function decompileXMLCdata(ast) {
   return "<![CDATA[" + ast.contents + "]]>";
 }
 
 function decompileXMLComment(ast) {
   return "<!--" + ast.comment + "-->";
 }
 
 function decompileXMLProcessingInstruction(ast) {
   return "<?" + ast.target + (ast.contents ? " " + ast.contents : "") + "?>";
 }

[Wladimir Palant, 2016/08/24 14:21:50]

It's probably better to just remove all functions related to XML literals -
these are no longer supported by SpiderMonkey (yes,
https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Parser...
appears to be outdated in this respect). So everything starting with `/* E4X */`
until this function can go.

[kzar, 2016/08/24 14:43:20]

Done.

 
 function process_js(ast) {
     _print(decompileAST(ast));
 }