When replacing an instruction with another in GVN-like optimizations, try to find a better user of …

lib/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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 24 matching lines @@
           // some patterns useful for type conversion.
           new SsaConstantFolder(backend, work, types),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler, types),
           new SsaCheckInserter(backend, types),
           new SsaConstantFolder(backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
+          // Previous optimizations may have generated new
+          // opportunities for constant folding.
+          new SsaConstantFolder(backend, work, types),
           new SsaDeadCodeEliminator(types),
           new SsaRegisterRecompilationCandidates(backend, work, types)];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
     JavaScriptItemCompilationContext context = work.compilationContext;
     HTypeMap types = context.types;
     return measure(() {
@@ skipping 868 matching lines @@
     }
     while (instruction !== null) {
       HInstruction next = instruction.next;
       int flags = instruction.getChangesFlags();
       assert(flags == 0 || !instruction.useGvn());
       values.kill(flags);
       if (instruction.useGvn()) {
         HInstruction other = values.lookup(instruction);
         if (other !== null) {
           assert(other.gvnEquals(instruction) && instruction.gvnEquals(other));
-          block.rewrite(instruction, other);
+          block.rewriteWithBetterUser(instruction, other);
           block.remove(instruction);
         } else {
           values.add(instruction);
         }
       }
       instruction = next;
     }
 
     List<HBasicBlock> dominatedBlocks = block.dominatedBlocks;
     for (int i = 0, length = dominatedBlocks.length; i < length; i++) {
@@ skipping 121 matching lines @@
         List<HInstruction> list = instructions.toList();
         for (HInstruction instruction in list) {
           // Move the instruction to the current block.
           instruction.block.detach(instruction);
           block.moveAtExit(instruction);
           // Go through all successors and rewrite their instruction
           // to the shared one.
           for (final successor in successors) {
             HInstruction toRewrite = values[successor.id].lookup(instruction);
             if (toRewrite != instruction) {
-              successor.rewrite(toRewrite, instruction);
+              successor.rewriteWithBetterUser(toRewrite, instruction);
               successor.remove(toRewrite);
             }
           }
         }
       }
     }
 
     // Don't try to merge instructions to a dominator if we have
     // multiple predecessors.
     if (block.predecessors.length != 1) return;
@@ skipping 243 matching lines @@
       // this type for the field is still a strong signal
       // indicating the expected type of the field.
       types[field] = type;
     } else {
       // If there are no invoked setters we know the type of
       // this field for sure.
       field.guaranteedType = type;
     }
   }
 }