dart2js: Split the SimplifyInterceptors pass out from the list of optimization passes.

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaOptimizerTask(JavaScriptBackend backend)
-    : this.backend = backend,
-      super(backend.compiler);
+      : this.backend = backend,
+        super(backend.compiler);
   String get name => 'SSA optimizer';
   Compiler get compiler => backend.compiler;
   Map<HInstruction, Range> ranges = <HInstruction, Range>{};
 
-  void runPhases(HGraph graph, List<OptimizationPhase> phases) {
-    for (OptimizationPhase phase in phases) {
-      runPhase(graph, phase);
+  void optimize(CodegenWorkItem work, HGraph graph) {
+    void runPhase(OptimizationPhase phase) {
+      phase.visitGraph(graph);
+      compiler.tracer.traceGraph(phase.name, graph);
+      assert(graph.isValid());
     }
-  }
 
-  void runPhase(HGraph graph, OptimizationPhase phase) {
-    phase.visitGraph(graph);
-    compiler.tracer.traceGraph(phase.name, graph);
-    assert(graph.isValid());
-  }
-
-  void optimize(CodegenWorkItem work, HGraph graph) {
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     bool trustPrimitives = compiler.trustPrimitives;
     measure(() {
-      SsaDeadCodeEliminator dce;
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial instruction simplification first to optimize
           // some patterns useful for type conversion.
           new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaTypeConversionInserter(compiler),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           // After type propagation, more instructions can be
           // simplified.
@@ skipping 14 matching lines @@
           new SsaCodeMotion(),
           new SsaLoadElimination(compiler),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
           // Previous optimizations may have generated new
           // opportunities for instruction simplification.
           new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaCheckInserter(
               trustPrimitives, backend, work, context.boundsChecked),
-          new SsaSimplifyInterceptors(compiler, constantSystem, work),
-          dce = new SsaDeadCodeEliminator(compiler, this),
-          new SsaTypePropagator(compiler)];
-      runPhases(graph, phases);
+      ];
+      phases.forEach(runPhase);
+
+      // Simplifying interceptors is not strictly just an optimization, it is
+      // required for implementation correctness because the code generator
+      // assumes it is always performed.

[Kevin Millikin (Google), 2015/03/13 10:18:04]

If this refactoring seems too aggressive, I could just commit a change that adds
this comment and nothing else (though I like the refactoring).

+      runPhase(new SsaSimplifyInterceptors(compiler, constantSystem, work));
+
+      SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(compiler, this);
+      runPhase(dce);
       if (dce.eliminatedSideEffects) {
         phases = <OptimizationPhase>[
+            new SsaTypePropagator(compiler),
             new SsaGlobalValueNumberer(compiler),
             new SsaCodeMotion(),
             new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
             new SsaInstructionSimplifier(constantSystem, backend, this, work),
             new SsaCheckInserter(
                 trustPrimitives, backend, work, context.boundsChecked),
             new SsaSimplifyInterceptors(compiler, constantSystem, work),
-            new SsaDeadCodeEliminator(compiler, this)];
+            new SsaDeadCodeEliminator(compiler, this),
+        ];
       } else {
         phases = <OptimizationPhase>[
-            // Run the simplifier to remove unneeded type checks inserted
-            // by type propagation.
-            new SsaInstructionSimplifier(constantSystem, backend, this, work)];
+            new SsaTypePropagator(compiler),
+            // Run the simplifier to remove unneeded type checks inserted by
+            // type propagation.
+            new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        ];
       }
-      runPhases(graph, phases);
+      phases.forEach(runPhase);
     });
   }
 }
 
 bool isFixedLength(mask, Compiler compiler) {
   ClassWorld classWorld = compiler.world;
   JavaScriptBackend backend = compiler.backend;
   if (mask.isContainer && mask.length != null) {
     // A container on which we have inferred the length.
     return true;
@@ skipping 2098 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }