Issue 4353 - Remove non standard for each syntax

utils/cleanast.js

 /**
  * A brief description of some nodes.
  *
  * Scope block information:
  *  variables (Variable[]): a list of variables declared in the block
  *  functions (Function[]): a list of functions declared in the block
  *  constants (Variable[]): a list of constants declared in the block
  *  classes (Class[]): a list of classes declared in the block
  *  objects (Class[]): a list of objects declared in the block
  *  code (Statement[]): a list of statements in the block
  */
 
 /**
  * Takes the node rooted at the AST and decomposes it into readable sections.
  */
 function clean_ast(ast) {
   assert(ast.type == TOK_LC);
   let info = {
     variables: [],
     constants: [],
     objects: [],
     classes: [],
     functions: [],
     code: []
   };
 
-  for each (let statement in ast.kids) {
+  for (let statement of ast.kids) {
     if (statement.op == JSOP_DEFVAR) {
       let ret = make_variables(statement);
       info.variables = info.variables.concat(ret.vars);
       info.objects = info.objects.concat(ret.objs);
     } else if (statement.op == JSOP_DEFCONST) {
       let ret = make_variables(statement);
       info.constants = info.constants.concat(ret.vars);
       info.objects = info.objects.concat(ret.objs);
     } else if (statement.type == TOK_FUNCTION) {
       info.functions.push(make_function(statement));
     } else if (prototype_assign(statement)) {
       let obj = make_class(statement);
       merge_class(info, obj);
     } else {
       info.code.push(statement);
     }
   }
   return info;
 }
 
 /**
  * Visits the AST using the given function as a parameter.
  * The parameter will take in a single argument, the AST node.
  */
 function visit(root_ast, func, to_expand) {
   function v_r(ast, func) {
     if (ast == null)
       return;
     if (func(ast)) return;
-    for each (let child in ast.kids)
+    for (let child of ast.kids)
       v_r(child, func);
   }
 
   function sanitize(ast) {
     if (ast == null)
       return null;
     if (ast.op == JSOP_NAME && ast.atom in to_expand) {
       ast = sanitize(to_expand[ast.atom]);
       ast.expanded = true;
     }
     let sanitized_ast = { kids: [] };
-    for (let key in ast) {
+    for (let key of ast) {
       if (key == 'kids') {
-        for each (let kid in ast.kids) {
+        for (let kid of ast.kids) {
           sanitized_ast.kids.push(sanitize(kid));
         }
       } else {
         sanitized_ast[key] = ast[key];
       }
     }
     return sanitized_ast;
   }
 
   if (to_expand)
@@ skipping 68 matching lines @@
       }
     }
   } else {
     info_list.classes = info_list.classes.concat(obj);
   }
 }
 function make_variables(var_root) {
   assert(var_root.op == JSOP_DEFVAR || var_root.op == JSOP_DEFCONST);
   let variables = [];
   let objects = [];
-  for each (let name in var_root.kids) {
+  for (let name of var_root.kids) {
     let v = { name: name.atom };
     v.init = (name.kids.length > 0 ? name.kids[0] : null);
     v.loc = get_location(var_root);
     if (v.init && v.init.op == JSOP_NEWINIT && v.init.kids[0] &&
         v.init.kids[0].type == TOK_COLON)
       objects.push(make_object(v));
     else
       variables.push(v);
   }
   return { vars: variables, objs: objects };
 }
 
 function make_object(stub) {
   stub.variables = {};
   stub.functions = {};
   stub.getters = {};
   stub.setters = {};
   let ast = stub.init;
   let proto = stub.init.op == JSOP_GETPROP && stub.init.atom == 'prototype';
   delete stub['init'];
   if (proto) {
-          stub.inherits = [ast.kids[0].atom];
-          return stub;
+    stub.inherits = [ast.kids[0].atom];
+    return stub;
   }
-  for each (let init in ast.kids) {
+  for (let init of ast.kids) {
     if (init.type != TOK_COLON) {
       dump_ast(init);
     }
     assert(init.type == TOK_COLON);
     if (init.kids[0].type == TOK_NAME) {
       let name = init.kids[0].atom;
       let value = init.kids[1];
       if (init.op == JSOP_GETTER)
         stub.getters[name] = make_function(value);
       else if (init.op == JSOP_SETTER)
@@ skipping 43 matching lines @@
 
 function assert(cmd) {
   if (!cmd) {
     throw new Error("Assertion failed");
   }
 }
 
 function get_location(ast_node) {
   return { line: ast_node.line, column: ast_node.column };
 }