anchor.diff:  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 runPhase(HGraph graph, OptimizationPhase phase) {
  -    phase.visitGraph(graph);
  -    compiler.tracer.traceGraph(phase.name, graph);
  -    assert(graph.isValid());
  -  }
  -
     void optimize(CodegenWorkItem work, HGraph graph) {
  +    void runPhase(OptimizationPhase phase) {
  +      phase.visitGraph(graph);
  +      compiler.tracer.traceGraph(phase.name, graph);
  +      assert(graph.isValid());
  +    }
  +
       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.
  
positive.code:             new SsaCheckInserter(
                  trustPrimitives, backend, work, context.boundsChecked),
              new SsaSimplifyInterceptors(compiler, constantSystem, work),
              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)];
        }
        runPhases(graph, phases);
      });
    }
  }
  
negative.code:           new SsaInstructionSimplifier(constantSystem, backend, this, work),
            new SsaCheckInserter(
                trustPrimitives, backend, work, context.boundsChecked),
        ];
        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.
        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),
  