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

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

Index: sdk/lib/_internal/compiler/implementation/ssa/nodes.dart
===================================================================
--- sdk/lib/_internal/compiler/implementation/ssa/nodes.dart	(revision 21808)
+++ sdk/lib/_internal/compiler/implementation/ssa/nodes.dart	(working copy)
@@ -903,6 +903,9 @@
    */
   HType instructionType = HType.UNKNOWN;
 
+  Selector get selector => null;
+  HInstruction getDartReceiver(Compiler compiler) => null;
+
   bool isInBasicBlock() => block != null;
 
   String inputsToString() {
@@ -1135,7 +1138,7 @@
     }
   }
 
-    /**
+  /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
@@ -1227,7 +1230,7 @@
 
   // A [HTypeGuard] cannot be moved anywhere in the graph, otherwise
   // instructions that have side effects could end up before the guard
-  // in the otpimized version, and after the guard in a bailout
+  // in the optimized version, and after the guard in a bailout
   // version.
   bool isPure() => false;
 
@@ -1565,7 +1568,8 @@
 }
 
 abstract class HInvokeBinary extends HInstruction {
-  HInvokeBinary(HInstruction left, HInstruction right)
+  Selector selector;

[kasperl, 2013/04/23 06:12:43]

final?

[ngeoffray, 2013/04/23 08:06:04]

Done.

+  HInvokeBinary(HInstruction left, HInstruction right, this.selector)
       : super(<HInstruction>[left, right]) {
     clearAllSideEffects();
     setUseGvn();
@@ -1578,12 +1582,12 @@
 }
 
 abstract class HBinaryArithmetic extends HInvokeBinary {
-  HBinaryArithmetic(HInstruction left, HInstruction right) : super(left, right);
+  HBinaryArithmetic(left, right, selector) : super(left, right, selector);
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
-  HAdd(HInstruction left, HInstruction right) : super(left, right);
+  HAdd(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1594,7 +1598,7 @@
 }
 
 class HDivide extends HBinaryArithmetic {
-  HDivide(HInstruction left, HInstruction right) : super(left, right) {
+  HDivide(left, right, selector) : super(left, right, selector) {
     instructionType = HType.DOUBLE;
   }
   accept(HVisitor visitor) => visitor.visitDivide(this);
@@ -1607,7 +1611,7 @@
 }
 
 class HMultiply extends HBinaryArithmetic {
-  HMultiply(HInstruction left, HInstruction right) : super(left, right);
+  HMultiply(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
   BinaryOperation operation(ConstantSystem operations)
@@ -1618,7 +1622,7 @@
 }
 
 class HSubtract extends HBinaryArithmetic {
-  HSubtract(HInstruction left, HInstruction right) : super(left, right);
+  HSubtract(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1652,13 +1656,13 @@
 }
 
 abstract class HBinaryBitOp extends HInvokeBinary {
-  HBinaryBitOp(HInstruction left, HInstruction right) : super(left, right) {
+  HBinaryBitOp(left, right, selector) : super(left, right, selector) {
     instructionType = HType.INTEGER;
   }
 }
 
 class HShiftLeft extends HBinaryBitOp {
-  HShiftLeft(HInstruction left, HInstruction right) : super(left, right);
+  HShiftLeft(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1669,7 +1673,7 @@
 }
 
 class HBitOr extends HBinaryBitOp {
-  HBitOr(HInstruction left, HInstruction right) : super(left, right);
+  HBitOr(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1680,7 +1684,7 @@
 }
 
 class HBitAnd extends HBinaryBitOp {
-  HBitAnd(HInstruction left, HInstruction right) : super(left, right);
+  HBitAnd(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1691,7 +1695,7 @@
 }
 
 class HBitXor extends HBinaryBitOp {
-  HBitXor(HInstruction left, HInstruction right) : super(left, right);
+  HBitXor(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1702,7 +1706,9 @@
 }
 
 abstract class HInvokeUnary extends HInstruction {
-  HInvokeUnary(HInstruction input) : super(<HInstruction>[input]) {
+  final Selector selector;
+  HInvokeUnary(HInstruction input, this.selector)
+      : super(<HInstruction>[input]) {
     clearAllSideEffects();
     setUseGvn();
   }
@@ -1713,7 +1719,7 @@
 }
 
 class HNegate extends HInvokeUnary {
-  HNegate(HInstruction input) : super(input);
+  HNegate(input, selector) : super(input, selector);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   UnaryOperation operation(ConstantSystem constantSystem)
@@ -1724,7 +1730,7 @@
 }
 
 class HBitNot extends HInvokeUnary {
-  HBitNot(HInstruction input) : super(input) {
+  HBitNot(input, selector) : super(input, selector) {
     instructionType = HType.INTEGER;
   }
   accept(HVisitor visitor) => visitor.visitBitNot(this);
@@ -1958,13 +1964,13 @@
 
 abstract class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
-  HRelational(HInstruction left, HInstruction right) : super(left, right) {
+  HRelational(left, right, selector) : super(left, right, selector) {
     instructionType = HType.BOOLEAN;
   }
 }
 
 class HIdentity extends HRelational {
-  HIdentity(HInstruction left, HInstruction right) : super(left, right);
+  HIdentity(left, right, [selector]) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1975,7 +1981,7 @@
 }
 
 class HGreater extends HRelational {
-  HGreater(HInstruction left, HInstruction right) : super(left, right);
+  HGreater(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitGreater(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1986,7 +1992,7 @@
 }
 
 class HGreaterEqual extends HRelational {
-  HGreaterEqual(HInstruction left, HInstruction right) : super(left, right);
+  HGreaterEqual(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -1997,7 +2003,7 @@
 }
 
 class HLess extends HRelational {
-  HLess(HInstruction left, HInstruction right) : super(left, right);
+  HLess(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitLess(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -2008,7 +2014,7 @@
 }
 
 class HLessEqual extends HRelational {
-  HLessEqual(HInstruction left, HInstruction right) : super(left, right);
+  HLessEqual(left, right, selector) : super(left, right, selector);
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
@@ -2152,7 +2158,8 @@
  * does not throw because we generate the checks explicitly.
  */
 class HIndex extends HInstruction {
-  HIndex(HInstruction receiver, HInstruction index)
+  final Selector selector;
+  HIndex(HInstruction receiver, HInstruction index, this.selector)
       : super(<HInstruction>[receiver, index]) {
     clearAllSideEffects();
     setDependsOnIndexStore();
@@ -2175,9 +2182,11 @@
  * does not throw because we generate the checks explicitly.
  */
 class HIndexAssign extends HInstruction {
+  final Selector selector;
   HIndexAssign(HInstruction receiver,
                HInstruction index,
-               HInstruction value)
+               HInstruction value,
+               this.selector)
       : super(<HInstruction>[receiver, index, value]) {
     clearAllSideEffects();
     setChangesIndex();
@@ -2239,16 +2248,20 @@
 class HTypeConversion extends HCheck {
   final DartType typeExpression;
   final int kind;
+  final Selector receiverTypeCheckSelector;
 
   static const int NO_CHECK = 0;
   static const int CHECKED_MODE_CHECK = 1;
   static const int ARGUMENT_TYPE_CHECK = 2;
   static const int CAST_TYPE_CHECK = 3;
   static const int BOOLEAN_CONVERSION_CHECK = 4;
+  static const int RECEIVER_TYPE_CHECK = 5;
 
   HTypeConversion(this.typeExpression, this.kind,
-                  HType type, HInstruction input)
+                  HType type, HInstruction input,
+                  [this.receiverTypeCheckSelector])
       : super(<HInstruction>[input]) {
+    assert(!isReceiverTypeCheck || receiverTypeCheckSelector != null);
     sourceElement = input.sourceElement;
     instructionType = type;
   }
@@ -2259,13 +2272,14 @@
         || kind == BOOLEAN_CONVERSION_CHECK;
   }
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
+  bool get isReceiverTypeCheck => kind == RECEIVER_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
   bool get isBooleanConversionCheck => kind == BOOLEAN_CONVERSION_CHECK;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
-  bool isJsStatement() => kind == ARGUMENT_TYPE_CHECK;
-  bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
+  bool isJsStatement() => isControlFlow();
+  bool isControlFlow() => isArgumentTypeCheck || isReceiverTypeCheck;
   bool canThrow() => isChecked;
 
   int typeCode() => HInstruction.TYPE_CONVERSION_TYPECODE;