Throw NoSuchMethod or ArgumentError instead of generating a bailout, when we know the next instruct…

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 55 matching lines @@
     });
   }
 
   bool trySpeculativeOptimizations(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField()) {
       // Lazy initializers may not have bailout methods.
       return false;
     }
     JavaScriptItemCompilationContext context = work.compilationContext;
     return measure(() {
+      SsaTypeGuardInserter inserter = new SsaTypeGuardInserter(compiler, work);
+
       // Run the phases that will generate type guards.
       List<OptimizationPhase> phases = <OptimizationPhase>[
-          new SsaTypeGuardInserter(compiler, work),
+          inserter,
           new SsaEnvironmentBuilder(compiler),
           // Then run the [SsaCheckInserter] because the type propagator also
           // propagated types non-speculatively. For example, it might have
           // propagated the type array for a call to the List constructor.
           new SsaCheckInserter(backend, work, context.boundsChecked)];
       runPhases(graph, phases);
+
+      if (work.guards.isEmpty && inserter.hasInsertedChecks) {
+        // If there is no guard, and we have inserted type checks
+        // instead, we can do the optimizations right away and avoid
+        // the bailout method.
+        optimize(work, graph, false);
+      }
       return !work.guards.isEmpty;
     });
   }
 
   void prepareForSpeculativeOptimizations(CodegenWorkItem work, HGraph graph) {
     JavaScriptItemCompilationContext context = work.compilationContext;
     measure(() {
       // In order to generate correct code for the bailout version, we did not
       // propagate types from the instruction to the type guard. We do it
       // now to be able to optimize further.
@@ skipping 848 matching lines @@
 
     HBoundsCheck check = new HBoundsCheck(index, length);
     node.block.addBefore(node, check);
     boundsChecked.add(node);
     return check;
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
     HIntegerCheck check = new HIntegerCheck(value);
     node.block.addBefore(node, check);
-    Set<HInstruction> dominatedUsers = value.dominatedUsers(node);
-    for (HInstruction user in dominatedUsers) {
-      user.changeUse(value, check);
-    }
+    value.replaceAllUsersDominatedBy(node, check);
     return check;
   }
 
   void visitIndex(HIndex node) {
     if (boundsChecked.contains(node)) return;
     HInstruction index = node.index;
     if (!node.index.isInteger()) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
@@ skipping 730 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }