Issue 4353 - Remove non standard for each syntax

utils/astml.js

 // Output an JsonML codec for the AST
 
 // Explanation of a node:
 // {
 //   type: The type of the node
 //   location: "line:col-line:col"
 // }
 /**
  * Node formats:
  * Program
@@ skipping 89 matching lines @@
 function walkAST(ast, visitor) {
   function astVisitor(node) {
     let info = structure[node.type];
     if (!info)
       throw "Need to define " + node.type;
     let cback = "visit" + node.type;
     let deep = false;
     if (cback in visitor)
       deep = visitor[cback](node);
     if (!deep) {
-      for each (let part in info) {
+      for (let part of info) {
         let piece = node[part];
         if (piece instanceof Array) {
-          [astVisitor(x) for each (x in piece)];
+          piece.map(astVisitor);
         } else if (piece) {
           astVisitor(piece);
         }
       }
     }
     cback = "post" + cback;
     if (cback in visitor)
       visitor[cback](node);
   }
   astVisitor(ast);
@@ skipping 212 matching lines @@
   let ast = shellNode(pn, "MemberExpression");
   ast.precedence = 1;
   ast.container = parseToAst(pn.kids[0]);
   ast.member = parseToAst(pn.kids[1]);
   return ast;
 }
 
 function convertTOK_RB(pn) {
   let ast = shellNode(pn, "ArrayLiteral");
   ast.precedence = 0;
-  ast.members = [parseToAst(x) for each (x in pn.kids)];
+  ast.members = pn.kids.map(parseToAst);
   return ast;
 }
 
 /* Returns a list */
 function convertTOK_LC(pn) {
   let ast = shellNode(pn, "BlockStatement");
-  ast.statements = [parseToAst(x) for each (x in pn.kids)];
+  ast.statements = pn.kinds.map(parseToAst);
   if (ast.statements.length == 0) {
     return shellNode(pn, "EmptyStatement");
   }
   return ast;
 }
 
 function convertTOK_RC(pn) {
   let ast = shellNode(pn, "ObjectLiteral");
-  ast.setters = [parseToAst(x) for each (x in pn.kids)];
+  ast.setters = pn.kids.map(parseToAst);
   return ast;
 }
 
 function convertTOK_LP(pn) {
   if (pn.op != JSOP_CALL && pn.op != JSOP_APPLY) {
     let ast = shellNode(pn, "LetStatement");
-    ast.variables = [parseToAst(x) for each (x in pn.kids)];
+    ast.variables = pn.kids.map(parseToAst);
     return ast;
   }
   let ast = shellNode(pn, "CallExpression");
   ast.precedence = 2;
   ast.func = parseToAst(pn.kids[0]);
   ast.arguments = [];
   for (let i = 1; i < pn.kids.length; i++)
     ast.arguments[i - 1] = parseToAst(pn.kids[i]);
   return ast;
 }
@@ skipping 156 matching lines @@
 }
 
 function convertTOK_IN(pn) { return binaryNode(pn, "in", 8); }
 
 function convertTOK_VAR(pn) {
   let ast = shellNode(pn, "VarStatement");
   if (pn.op == JSOP_DEFCONST)
     ast.vartype = "const";
   else
     ast.vartype = "var";
-  ast.variables = [parseToAst(x) for each (x in pn.kids)];
-  for each (let x in ast.variables) {
+  ast.variables = pn.kids.map(parseToAst);
+  for (let x of ast.variables) {
     if (x.type == "LetStatement")
       return x;
     if (x.type == "IdentifierExpression")
       x.type = "VarDeclaration";
   }
   return ast;
 }
 
 function convertTOK_WITH(pn) {
   let ast = shellNode(pn, "WithStatement");
@@ skipping 114 matching lines @@
   ast.init = pn.kids[0] ? parseToAst(pn.kids[0]) :
     shellNode(pn, "EmptyStatement");
   ast.condition = pn.kids[1] ? parseToAst(pn.kids[1]) :
     shellNode(pn, "EmptyStatement");
   ast.increment = pn.kids[2] ? parseToAst(pn.kids[2]) :
     shellNode(pn, "EmptyStatement");
   return ast;
 }
 
 function convertTOK_RESERVED(pn) {
-  return [parseToAst(x) for each (x in pn.kids)];
+  return pn.kids.map(parseToAst);
 }