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

sdk/lib/_internal/compiler/implementation/ssa/invoke_dynamic_specializers.dart

 // Copyright (c) 2013, 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;
 
 /**
  * [InvokeDynamicSpecializer] and its subclasses are helpers to
  * optimize intercepted dynamic calls. It knows what input types
  * would be beneficial for performance, and how to change a invoke
@@ skipping 84 matching lines @@
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     if (instruction.inputs[1].isMutableArray()) {
       return new HIndexAssign(instruction.inputs[1],
                               instruction.inputs[2],
-                              instruction.inputs[3]);
+                              instruction.inputs[3],
+                              instruction.selector);
     }
     return null;
   }
 }
 
 class IndexSpecializer extends InvokeDynamicSpecializer {
   const IndexSpecializer();
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     HInstruction index = instruction.inputs[2];
     if (input == instruction.inputs[1] &&
         index.instructionType.canBePrimitiveNumber(compiler)) {
       return HType.INDEXABLE_PRIMITIVE;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     if (instruction.inputs[1].isIndexablePrimitive()) {
-      return new HIndex(instruction.inputs[1], instruction.inputs[2]);
+      return new HIndex(
+          instruction.inputs[1], instruction.inputs[2], instruction.selector);
     }
     return null;
   }
 }
 
 class BitNotSpecializer extends InvokeDynamicSpecializer {
   const BitNotSpecializer();
 
   UnaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitNot;
@@ skipping 15 matching lines @@
                                   Compiler compiler) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (instruction.inputs[1].isPrimitive()) return HType.INTEGER;
     return instruction.instructionType;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction input = instruction.inputs[1];
-    if (input.isNumber()) return new HBitNot(input);
+    if (input.isNumber()) return new HBitNot(input, instruction.selector);
     return null;
   }
 }
 
 class UnaryNegateSpecializer extends InvokeDynamicSpecializer {
   const UnaryNegateSpecializer();
 
   UnaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.negate;
   }
@@ skipping 15 matching lines @@
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     HType operandType = instruction.inputs[1].instructionType;
     if (operandType.isNumber()) return operandType;
     return instruction.instructionType;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction input = instruction.inputs[1];
-    if (input.isNumber()) return new HNegate(input);
+    if (input.isNumber()) return new HNegate(input, instruction.selector);
     return null;
   }
 }
 
 abstract class BinaryArithmeticSpecializer extends InvokeDynamicSpecializer {
   const BinaryArithmeticSpecializer();
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     HInstruction left = instruction.inputs[1];
@@ skipping 35 matching lines @@
   }
 
   bool isBuiltin(HInvokeDynamic instruction) {
     return instruction.inputs[1].isNumber()
         && instruction.inputs[2].isNumber();
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     if (isBuiltin(instruction)) {
-      HInstruction builtin =
-          newBuiltinVariant(instruction.inputs[1], instruction.inputs[2]);
+      HInstruction builtin = newBuiltinVariant(instruction);
       if (builtin != null) return builtin;
       // Even if there is no builtin equivalent instruction, we know
       // the instruction does not have any side effect, and that it
       // can be GVN'ed.
       instruction.clearAllSideEffects();
       instruction.clearAllDependencies();
       instruction.setUseGvn();
     }
     return null;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction);
 }
 
 class AddSpecializer extends BinaryArithmeticSpecializer {
   const AddSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.add;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HAdd(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HAdd(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class DivideSpecializer extends BinaryArithmeticSpecializer {
   const DivideSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.divide;
   }
 
   HType computeTypeFromInputTypes(HInstruction instruction,
                                   Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     if (left.isNumber()) return HType.DOUBLE;
     return instruction.instructionType;
   }
 
   HType computeDesiredTypeForInput(HInstruction instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     if (input == instruction.inputs[0]) return HType.UNKNOWN;
     // A division can never return an integer. So don't ask for integer inputs.
     if (instruction.isInteger()) return HType.UNKNOWN;
     return super.computeDesiredTypeForInput(
         instruction, input, compiler);
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HDivide(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HDivide(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class ModuloSpecializer extends BinaryArithmeticSpecializer {
   const ModuloSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.modulo;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
     // Modulo cannot be mapped to the native operator (different semantics).    
     return null;
   }
 }
 
 class MultiplySpecializer extends BinaryArithmeticSpecializer {
   const MultiplySpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.multiply;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HMultiply(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HMultiply(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class SubtractSpecializer extends BinaryArithmeticSpecializer {
   const SubtractSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.subtract;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HSubtract(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HSubtract(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class TruncatingDivideSpecializer extends BinaryArithmeticSpecializer {
   const TruncatingDivideSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.truncatingDivide;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
     // Truncating divide does not have a JS equivalent.    
     return null;
   }
 }
 
 abstract class BinaryBitOpSpecializer extends BinaryArithmeticSpecializer {
   const BinaryBitOpSpecializer();
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
@@ skipping 28 matching lines @@
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (!left.isNumber() || !right.isConstantInteger()) return null;
     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     if (count >= 0 && count <= 31) {
-      return newBuiltinVariant(left, right);
+      return newBuiltinVariant(instruction);
     }
     return null;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HShiftLeft(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HShiftLeft(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class ShiftRightSpecializer extends BinaryBitOpSpecializer {
   const ShiftRightSpecializer();
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
     // Shift right cannot be mapped to the native operator easily.    
     return null;
   }
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.shiftRight;
   }
 }
 
 class BitOrSpecializer extends BinaryBitOpSpecializer {
   const BitOrSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitOr;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HBitOr(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HBitOr(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class BitAndSpecializer extends BinaryBitOpSpecializer {
   const BitAndSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitAnd;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HBitAnd(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HBitAnd(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class BitXorSpecializer extends BinaryBitOpSpecializer {
   const BitXorSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitXor;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HBitXor(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HBitXor(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 abstract class RelationalSpecializer extends InvokeDynamicSpecializer {
   const RelationalSpecializer();
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     if (instruction.inputs[1].instructionType.isPrimitiveOrNull()) {
       return HType.BOOLEAN;
@@ skipping 16 matching lines @@
       }
     }
     return HType.UNKNOWN;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber() && right.isNumber()) {
-      return newBuiltinVariant(left, right);
+      return newBuiltinVariant(instruction);
     }
     return null;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction);
 }
 
 class EqualsSpecializer extends RelationalSpecializer {
   const EqualsSpecializer();
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
@@ skipping 17 matching lines @@
     }
     return HType.UNKNOWN;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     HType instructionType = left.instructionType;
     if (right.isConstantNull() || instructionType.isPrimitiveOrNull()) {
-      return newBuiltinVariant(left, right);
+      return newBuiltinVariant(instruction);
     }
     TypeMask mask = instructionType.computeMask(compiler);
     Selector selector = new TypedSelector(mask, instruction.selector);
     World world = compiler.world;
     JavaScriptBackend backend = compiler.backend;
     Iterable<Element> matches = world.allFunctions.filter(selector);
     // This test relies the on `Object.==` and `Interceptor.==` always being
     // implemented because if the selector matches by subtype, it still will be
     // a regular object or an interceptor.
     if (matches.every(backend.isDefaultEqualityImplementation)) {
-      return newBuiltinVariant(left, right);
+      return newBuiltinVariant(instruction);
     }
     return null;
   }
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.equal;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HIdentity(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HIdentity(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class LessSpecializer extends RelationalSpecializer {
   const LessSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.less;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HLess(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HLess(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class GreaterSpecializer extends RelationalSpecializer {
   const GreaterSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.greater;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HGreater(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HGreater(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class GreaterEqualSpecializer extends RelationalSpecializer {
   const GreaterEqualSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.greaterEqual;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HGreaterEqual(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HGreaterEqual(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }
 
 class LessEqualSpecializer extends RelationalSpecializer {
   const LessEqualSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.lessEqual;
   }
 
-  HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
-    return new HLessEqual(left, right);
+  HInstruction newBuiltinVariant(HInvokeDynamic instruction) {
+    return new HLessEqual(
+        instruction.inputs[1], instruction.inputs[2], instruction.selector);
   }
 }