Address long-standing review comments.

sdk/lib/_internal/compiler/implementation/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);
 }
@@ skipping 16 matching lines @@
     phase.visitGraph(graph);
     compiler.tracer.traceGraph(phase.name, graph);
     assert(graph.isValid());
   }
 
   void optimize(CodegenWorkItem work, HGraph graph, bool speculative) {
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
-          // Run trivial constant folding first to optimize
+          // Run trivial instruction simplification first to optimize
           // some patterns useful for type conversion.
-          new SsaConstantFolder(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, work),
           new SsaTypeConversionInserter(compiler),
           new SsaNonSpeculativeTypePropagator(compiler),
-          new SsaConstantFolder(constantSystem, backend, work),
-          // The constant folder affects the types of instructions, so
-          // we run the type propagator again. Note that this would
-          // not be necessary if types were directly stored on
-          // instructions.
-          new SsaNonSpeculativeTypePropagator(compiler),
+          // After type propagation, more instructions can be
+          // simplified.
+          new SsaInstructionSimplifier(constantSystem, backend, work),
           new SsaCheckInserter(backend, work, context.boundsChecked),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
-          new SsaConstantFolder(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, work),
           new SsaNonSpeculativeTypePropagator(compiler),
           // Run a dead code eliminator before LICM because dead
           // interceptors are often in the way of LICM'able instructions.
           new SsaDeadCodeEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(compiler, constantSystem, work),
           // Previous optimizations may have generated new
-          // opportunities for constant folding.
-          new SsaConstantFolder(constantSystem, backend, work),
+          // opportunities for instruction simplification.
+          new SsaInstructionSimplifier(constantSystem, backend, work),
           new SsaSimplifyInterceptors(compiler, constantSystem, work),
           new SsaDeadCodeEliminator()];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField()) {
       // Lazy initializers may not have bailout methods.
       return false;
@@ skipping 43 matching lines @@
           new SsaCheckInserter(backend, work, context.boundsChecked),
           new SsaNonSpeculativeTypePropagator(compiler)]);
     });
   }
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
-class SsaConstantFolder extends HBaseVisitor implements OptimizationPhase {
-  final String name = "SsaConstantFolder";
+class SsaInstructionSimplifier extends HBaseVisitor
+    implements OptimizationPhase {
+  final String name = "SsaInstructionSimplifier";
   final JavaScriptBackend backend;
   final CodegenWorkItem work;
   final ConstantSystem constantSystem;
   HGraph graph;
   Compiler get compiler => backend.compiler;
 
-  SsaConstantFolder(this.constantSystem, this.backend, this.work);
+  SsaInstructionSimplifier(this.constantSystem, this.backend, this.work);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
@@ skipping 1195 matching lines @@
       // that knows it is not of a specific Type.
     }
 
     for (HIf ifUser in notIfUsers) {
       changeUsesDominatedBy(ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }