Migrates PeepholeOptimizationsPass to the new changed scopes system.

Reduces peephole pass time by ~32%, from ~4300ms to ~2900ms
(averaged across 30 compiles, in [], performed locally).

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=161715016

src/com/google/javascript/jscomp/AbstractPeepholeOptimization.java

@@ -29,7 +29,6 @@
  */
 abstract class AbstractPeepholeOptimization {
 
-  private NodeTraversal traversal;
   protected AbstractCompiler compiler;
 
   /**
@@ -60,7 +59,7 @@ protected void report(DiagnosticType diagnostic, Node n) {
    * Subclasses must call these if they have changed the AST.
    */
   protected void reportCodeChange() {
-    traversal.reportCodeChange();
+    compiler.reportCodeChange();
   }
 
   /**
@@ -85,25 +84,11 @@ protected boolean isASTNormalized() {
     return compiler.getLifeCycleStage().isNormalized();
   }
 
-  /**
-   * Informs the optimization that a traversal will begin.
-   */
-  void beginTraversal(NodeTraversal traversal) {
-    this.traversal = traversal;
-    this.compiler = traversal.getCompiler();
+  /** Informs the optimization that a traversal will begin. */
+  void beginTraversal(AbstractCompiler compiler) {
+    this.compiler = compiler;
   }
 
-  /**
-   * Informs the optimization that a traversal has completed.
-   */
-  void endTraversal() {
-    this.traversal = null;
-    this.compiler = null;
-  }
-
-  // NodeUtil's mayEffectMutableState and mayHaveSideEffects need access to the
-  // compiler object, route them through here to give them access.
-
   /**
    * @return Whether the node may create new mutable state, or change existing
    * state.

src/com/google/javascript/jscomp/DefaultPassConfig.java

@@ -1640,12 +1640,11 @@ protected FeatureSet featureSet() {
 
   private final PassFactory earlyPeepholeOptimizations =
       new PassFactory("earlyPeepholeOptimizations", true) {
-    @Override
-    protected CompilerPass create(AbstractCompiler compiler) {
-      return new PeepholeOptimizationsPass(compiler,
-          new PeepholeRemoveDeadCode());
-    }
-  };
+        @Override
+        protected CompilerPass create(AbstractCompiler compiler) {
+          return new PeepholeOptimizationsPass(compiler, getName(), new PeepholeRemoveDeadCode());
+        }
+      };
 
   private final PassFactory earlyInlineVariables =
       new PassFactory("earlyInlineVariables", true) {
@@ -1669,54 +1668,59 @@ protected FeatureSet featureSet() {
   };
 
   /** Various peephole optimizations. */
-  private static CompilerPass createPeepholeOptimizationsPass(AbstractCompiler compiler) {
+  private static CompilerPass createPeepholeOptimizationsPass(
+      AbstractCompiler compiler, String passName) {
     final boolean late = false;
     final boolean useTypesForOptimization = compiler.getOptions().useTypesForLocalOptimization;
-    return new PeepholeOptimizationsPass(compiler,
-          new MinimizeExitPoints(compiler),
-          new PeepholeMinimizeConditions(late, useTypesForOptimization),
-          new PeepholeSubstituteAlternateSyntax(late),
-          new PeepholeReplaceKnownMethods(late, useTypesForOptimization),
-          new PeepholeRemoveDeadCode(),
-          new PeepholeFoldConstants(late, useTypesForOptimization),
-          new PeepholeCollectPropertyAssignments());
+    return new PeepholeOptimizationsPass(
+        compiler,
+        passName,
+        new MinimizeExitPoints(compiler),
+        new PeepholeMinimizeConditions(late, useTypesForOptimization),
+        new PeepholeSubstituteAlternateSyntax(late),
+        new PeepholeReplaceKnownMethods(late, useTypesForOptimization),
+        new PeepholeRemoveDeadCode(),
+        new PeepholeFoldConstants(late, useTypesForOptimization),
+        new PeepholeCollectPropertyAssignments());
   }
 
   /** Various peephole optimizations. */
   private final PassFactory peepholeOptimizations =
       new PassFactory(Compiler.PEEPHOLE_PASS_NAME, false /* oneTimePass */) {
-    @Override
-    protected CompilerPass create(AbstractCompiler compiler) {
-      return createPeepholeOptimizationsPass(compiler);
-    }
-  };
+        @Override
+        protected CompilerPass create(AbstractCompiler compiler) {
+          return createPeepholeOptimizationsPass(compiler, getName());
+        }
+      };
 
   /** Various peephole optimizations. */
   private final PassFactory peepholeOptimizationsOnce =
       new PassFactory(Compiler.PEEPHOLE_PASS_NAME, true /* oneTimePass */) {
-    @Override
-    protected CompilerPass create(AbstractCompiler compiler) {
-      return createPeepholeOptimizationsPass(compiler);
-    }
-  };
+        @Override
+        protected CompilerPass create(AbstractCompiler compiler) {
+          return createPeepholeOptimizationsPass(compiler, getName());
+        }
+      };
 
   /** Same as peepholeOptimizations but aggressively merges code together */
   private final PassFactory latePeepholeOptimizations =
       new PassFactory("latePeepholeOptimizations", true) {
-    @Override
-    protected CompilerPass create(AbstractCompiler compiler) {
-      final boolean late = true;
-      final boolean useTypesForOptimization = options.useTypesForLocalOptimization;
-      return new PeepholeOptimizationsPass(compiler,
-            new StatementFusion(options.aggressiveFusion),
-            new PeepholeRemoveDeadCode(),
-            new PeepholeMinimizeConditions(late, useTypesForOptimization),
-            new PeepholeSubstituteAlternateSyntax(late),
-            new PeepholeReplaceKnownMethods(late, useTypesForOptimization),
-            new PeepholeFoldConstants(late, useTypesForOptimization),
-            new ReorderConstantExpression());
-    }
-  };
+        @Override
+        protected CompilerPass create(AbstractCompiler compiler) {
+          final boolean late = true;
+          final boolean useTypesForOptimization = options.useTypesForLocalOptimization;
+          return new PeepholeOptimizationsPass(
+              compiler,
+              getName(),
+              new StatementFusion(options.aggressiveFusion),
+              new PeepholeRemoveDeadCode(),
+              new PeepholeMinimizeConditions(late, useTypesForOptimization),
+              new PeepholeSubstituteAlternateSyntax(late),
+              new PeepholeReplaceKnownMethods(late, useTypesForOptimization),
+              new PeepholeFoldConstants(late, useTypesForOptimization),
+              new ReorderConstantExpression());
+        }
+      };
 
   /** Checks that all variables are defined. */
   private final HotSwapPassFactory checkVars =
@@ -2689,17 +2693,14 @@ protected CompilerPass create(AbstractCompiler compiler) {
     }
   };
 
-  /**
-   * Some simple, local collapses (e.g., {@code var x; var y;} becomes
-   * {@code var x,y;}.
-   */
-  private final PassFactory exploitAssign = new PassFactory("exploitAssign", true) {
-    @Override
-    protected CompilerPass create(AbstractCompiler compiler) {
-      return new PeepholeOptimizationsPass(compiler,
-          new ExploitAssigns());
-    }
-  };
+  /** Some simple, local collapses (e.g., {@code var x; var y;} becomes {@code var x,y;}. */
+  private final PassFactory exploitAssign =
+      new PassFactory("exploitAssign", true) {
+        @Override
+        protected CompilerPass create(AbstractCompiler compiler) {
+          return new PeepholeOptimizationsPass(compiler, getName(), new ExploitAssigns());
+        }
+      };
 
   /**
    * Some simple, local collapses (e.g., {@code var x; var y;} becomes

src/com/google/javascript/jscomp/MinimizeExitPoints.java

@@ -40,7 +40,7 @@ class MinimizeExitPoints extends AbstractPeepholeOptimization {
 
   @VisibleForTesting
   final CompilerPass asCompilerPass() {
-    return new PeepholeOptimizationsPass(compiler, this);
+    return new PeepholeOptimizationsPass(compiler, this.getClass().getSimpleName(), this);
   }
 
   @Override

src/com/google/javascript/jscomp/PeepholeOptimizationsPass.java

@@ -16,9 +16,10 @@
 
 package com.google.javascript.jscomp;
 
-import com.google.javascript.jscomp.NodeTraversal.AbstractShallowCallback;
-import com.google.javascript.jscomp.NodeTraversal.FunctionCallback;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.javascript.jscomp.NodeTraversal.AbstractPostOrderCallback;
 import com.google.javascript.rhino.Node;
+import java.util.List;
 
 /**
  * A compiler pass to run various peephole optimizations (e.g. constant folding,
@@ -27,93 +28,61 @@
  * @author dcc@google.com (Devin Coughlin)
  */
 class PeepholeOptimizationsPass implements CompilerPass {
-  private AbstractCompiler compiler;
 
-  // Use an array here for faster iteration compared to ImmutableSet
+  private final AbstractCompiler compiler;
+  private final String passName;
   private final AbstractPeepholeOptimization[] peepholeOptimizations;
-
   private boolean retraverseOnChange;
-  private RecentChange handler;
-  private FunctionCallback fnCallback;
-  private PeepCallback peepCallback;
-  private NodeTraversal traversal;
 
-  /**
-   * Creates a peephole optimization pass that runs the given
-   * optimizations.
-   */
-  PeepholeOptimizationsPass(AbstractCompiler compiler,
-      AbstractPeepholeOptimization... optimizations) {
+  /** Creates a peephole optimization pass that runs the given optimizations. */
+  PeepholeOptimizationsPass(
+      AbstractCompiler compiler, String passName, AbstractPeepholeOptimization... optimizations) {
     this.compiler = compiler;
+    this.passName = passName;
     this.peepholeOptimizations = optimizations;
     this.retraverseOnChange = true;
-    this.handler = new RecentChange();
-    this.peepCallback = new PeepCallback();
-    this.traversal = new NodeTraversal(
-        compiler, peepCallback, new Es6SyntacticScopeCreator(compiler));
-    this.fnCallback = new ChangedFunctionCallback();
   }
 
+  @VisibleForTesting
   void setRetraverseOnChange(boolean retraverse) {
     this.retraverseOnChange = retraverse;
   }
 
   @Override
   public void process(Node externs, Node root) {
-    compiler.addChangeHandler(handler);
-    beginTraversal(traversal);
-    NodeTraversal.traverseChangedFunctions(compiler, fnCallback);
-    endTraversal();
-    compiler.removeChangeHandler(handler);
-  }
+    beginTraversal();
 
-  private class ChangedFunctionCallback implements FunctionCallback {
-    @Override
-    public void enterFunction(AbstractCompiler compiler, Node root) {
-      if (root.isFunction()) {
-        root = root.getLastChild();
+    // Repeat to an internal fixed point.
+    for (List<Node> changedScopeNodes = compiler.getChangedScopeNodesForPass(passName);
+        changedScopeNodes == null || !changedScopeNodes.isEmpty();
+        changedScopeNodes = compiler.getChangedScopeNodesForPass(passName)) {
+      NodeTraversal.traverseEs6ScopeRoots(
+          compiler, root, changedScopeNodes, new PeepCallback(), false);
+
+      // Cancel the fixed point if requested.
+      if (!retraverseOnChange) {
+        break;
       }
-      do {
-        handler.reset();
-        traversal.traverse(root);
-      } while (retraverseOnChange && handler.hasCodeChanged());
     }
   }
 
-  private class PeepCallback extends AbstractShallowCallback {
+  private class PeepCallback extends AbstractPostOrderCallback {
     @Override
     public void visit(NodeTraversal t, Node n, Node parent) {
-      Node currentNode = n, newNode;
-      boolean codeChanged = false;
-      do {
-        codeChanged = false;
-        for (AbstractPeepholeOptimization optim : peepholeOptimizations) {
-          newNode = optim.optimizeSubtree(currentNode);
-          if (newNode != currentNode) {
-            codeChanged = true;
-            currentNode = newNode;
-          }
-          if (currentNode == null) {
-            return;
-          }
+      Node currentNode = n;
+      for (AbstractPeepholeOptimization optim : peepholeOptimizations) {
+        currentNode = optim.optimizeSubtree(currentNode);
+        if (currentNode == null) {
+          return;
         }
-      } while(codeChanged);
-    }
-  }
-
-  /**
-   * Make sure that all the optimizations have the current traversal so they
-   * can report errors.
-   */
-  private void beginTraversal(NodeTraversal traversal) {
-    for (AbstractPeepholeOptimization optimization : peepholeOptimizations) {
-      optimization.beginTraversal(traversal);
+      }
     }
   }
 
-  private void endTraversal() {
+  /** Make sure that all the optimizations have the current compiler so they can report errors. */
+  private void beginTraversal() {
     for (AbstractPeepholeOptimization optimization : peepholeOptimizations) {
-      optimization.endTraversal();
+      optimization.beginTraversal(compiler);
     }
   }
 }

src/com/google/javascript/jscomp/PeepholeSubstituteAlternateSyntax.java

@@ -95,6 +95,7 @@ public Node optimizeSubtree(Node node) {
         return tryReduceReturn(node);
 
       case COMMA:
+        // TODO(b/63630312): should flatten an entire comma expression in a single pass.
         return trySplitComma(node);
 
       case NAME:
@@ -313,8 +314,8 @@ private Node trySplitComma(Node n) {
       Node newStatement = IR.exprResult(right);
       newStatement.useSourceInfoIfMissingFrom(n);
 
-      //This modifies outside the subtree, which is not
-      //desirable in a peephole optimization.
+      // This modifies outside the subtree, which is not
+      // desirable in a peephole optimization.
       parent.getParent().addChildAfter(newStatement, parent);
       reportCodeChange();
       return left;

test/com/google/javascript/jscomp/CreateSyntheticBlocksTest.java

@@ -41,13 +41,14 @@ protected CompilerPass getProcessor(final Compiler compiler) {
     return new CompilerPass() {
       @Override
       public void process(Node externs, Node js) {
-        new CreateSyntheticBlocks(compiler, START_MARKER, END_MARKER).process(
-            externs, js);
+        new CreateSyntheticBlocks(compiler, START_MARKER, END_MARKER).process(externs, js);
         new MinimizeExitPoints(compiler).asCompilerPass().process(externs, js);
-        new PeepholeOptimizationsPass(compiler,
-            new PeepholeRemoveDeadCode(),
-            new PeepholeMinimizeConditions(true /* late */, false /* useTypes */),
-            new PeepholeFoldConstants(true, false))
+        new PeepholeOptimizationsPass(
+                compiler,
+                getName(),
+                new PeepholeRemoveDeadCode(),
+                new PeepholeMinimizeConditions(true /* late */, false /* useTypes */),
+                new PeepholeFoldConstants(true, false))
             .process(externs, js);
         new MinimizeExitPoints(compiler).asCompilerPass().process(externs, js);
         new Denormalize(compiler).process(externs, js);

test/com/google/javascript/jscomp/ExploitAssignsTest.java

@@ -184,6 +184,6 @@ public void testIssue1017() {
 
   @Override
   protected CompilerPass getProcessor(Compiler compiler) {
-    return new PeepholeOptimizationsPass(compiler,new ExploitAssigns());
+    return new PeepholeOptimizationsPass(compiler, getName(), new ExploitAssigns());
   }
 }

test/com/google/javascript/jscomp/MultiPassTest.java

@@ -359,7 +359,9 @@ private void addPeephole() {
           @Override
           protected CompilerPass create(AbstractCompiler compiler) {
             final boolean late = false;
-            return new PeepholeOptimizationsPass(compiler,
+            return new PeepholeOptimizationsPass(
+                compiler,
+                getName(),
                 new PeepholeMinimizeConditions(late, false /* useTypes */),
                 new PeepholeSubstituteAlternateSyntax(late),
                 new PeepholeReplaceKnownMethods(late, false),

test/com/google/javascript/jscomp/PeepholeCollectPropertyAssignmentsTest.java

@@ -21,7 +21,7 @@ public final class PeepholeCollectPropertyAssignmentsTest extends CompilerTestCa
   @Override
   protected CompilerPass getProcessor(final Compiler compiler) {
     return new PeepholeOptimizationsPass(
-        compiler, new PeepholeCollectPropertyAssignments());
+        compiler, getName(), new PeepholeCollectPropertyAssignments());
   }
 
   public void test36122565a() {