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

sdk/lib/_internal/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 885 matching lines @@
   bool isPrimitive() => instructionType.isPrimitive();
   bool canBeNull() => instructionType.canBeNull();
   bool canBePrimitive(Compiler compiler) =>
       instructionType.canBePrimitive(compiler);
 
   /**
    * Type of the unstruction.
    */
   HType instructionType = HType.UNKNOWN;
 
+  Selector get selector => null;
+  HInstruction getDartReceiver(Compiler compiler) => null;
+
   bool isInBasicBlock() => block != null;
 
   String inputsToString() {
     void addAsCommaSeparated(StringBuffer buffer, List<HInstruction> list) {
       for (int i = 0; i < list.length; i++) {
         if (i != 0) buffer.write(', ');
         buffer.write("@${list[i].id}");
       }
     }
 
@@ skipping 145 matching lines @@
           users.remove(current);
           if (--usersInCurrentBlock == 0) break;
         }
         current = current.next;
       }
     }
 
     return users;
   }
 
+  void replaceAllUsersDominatedBy(HInstruction cursor,
+                                  HInstruction newInstruction) {
+    Set<HInstruction> users = dominatedUsers(cursor);
+    for (HInstruction user in users) {
+      user.changeUse(this, newInstruction);
+    }
+  }
+
   void moveBefore(HInstruction other) {
     assert(this is !HControlFlow);
     assert(this is !HPhi);
     assert(other is !HPhi);
     block.detach(this);
     other.block.internalAddBefore(other, this);
     block = other.block;
   }
 
   bool isConstant() => false;
@@ skipping 47 matching lines @@
       return new HTypeConversion(type, kind, HType.UNKNOWN, this);
     } else if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
       // Boolean conversion checks work on non-nullable booleans.
       return new HTypeConversion(type, kind, HType.BOOLEAN, this);
     } else {
       HType subtype = new HType.subtype(type, compiler);
       return new HTypeConversion(type, kind, subtype, this);
     }
   }
 
-    /**
+  /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
   bool hasSameLoopHeaderAs(HInstruction other) {
     return block.enclosingLoopHeader == other.block.enclosingLoopHeader;
   }
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]) {
@@ skipping 71 matching lines @@
     isEnabled = false;
     instructionType = guarded.instructionType;
   }
 
   bool isControlFlow() => true;
   bool isJsStatement() => isEnabled;
   bool canThrow() => isEnabled;
 
   // 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;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => HInstruction.TYPE_GUARD_TYPECODE;
   bool typeEquals(other) => other is HTypeGuard;
   bool dataEquals(HTypeGuard other) => guardedType == other.guardedType;
 }
 
 class HBoundsCheck extends HCheck {
@@ skipping 317 matching lines @@
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, HType type, List<HInstruction> inputs)
       : super(const LiteralDartString("new"), type, inputs);
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 abstract class HInvokeBinary extends HInstruction {
-  HInvokeBinary(HInstruction left, HInstruction right)
+  final Selector selector;
+  HInvokeBinary(HInstruction left, HInstruction right, this.selector)
       : super(<HInstruction>[left, right]) {
     clearAllSideEffects();
     setUseGvn();
   }
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 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)
       => constantSystem.add;
   int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 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);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.divide;
   int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => operations.multiply;
   int typeCode() => HInstruction.MULTIPLY_TYPECODE;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.subtract;
   int typeCode() => HInstruction.SUBTRACT_TYPECODE;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
@@ skipping 13 matching lines @@
    * following join-block.
    */
   HBasicBlock get defaultTarget => block.successors.last;
 
   accept(HVisitor visitor) => visitor.visitSwitch(this);
 
   String toString() => "HSwitch cases = $inputs";
 }
 
 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)
       => constantSystem.shiftLeft;
   int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.bitOr;
   int typeCode() => HInstruction.BIT_OR_TYPECODE;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.bitAnd;
   int typeCode() => HInstruction.BIT_AND_TYPECODE;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HInvokeUnary extends HInstruction {
-  HInvokeUnary(HInstruction input) : super(<HInstruction>[input]) {
+  final Selector selector;
+  HInvokeUnary(HInstruction input, this.selector)
+      : super(<HInstruction>[input]) {
     clearAllSideEffects();
     setUseGvn();
   }
 
   HInstruction get operand => inputs[0];
 
   UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 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)
       => constantSystem.negate;
   int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
-  HBitNot(HInstruction input) : super(input) {
+  HBitNot(input, selector) : super(input, selector) {
     instructionType = HType.INTEGER;
   }
   accept(HVisitor visitor) => visitor.visitBitNot(this);
   
   UnaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitNot;
   int typeCode() => HInstruction.BIT_NOT_TYPECODE;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
@@ skipping 213 matching lines @@
     assert(logicalOperatorType == IS_OR);
     return "||";
   }
 
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 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)
       => constantSystem.identity;
   int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.greater;
   int typeCode() => HInstruction.GREATER_TYPECODE;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.greaterEqual;
   int typeCode() => HInstruction.GREATER_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.less;
   int typeCode() => HInstruction.LESS_TYPECODE;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 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)
       => constantSystem.lessEqual;
   int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
@@ skipping 123 matching lines @@
   }
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 }
 
 /**
  * The primitive array indexing operation. Note that this instruction
  * 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();
     setUseGvn();
   }
 
   String toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
 
   int typeCode() => HInstruction.INDEX_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIndex;
   bool dataEquals(HIndex other) => true;
 }
 
 /**
  * The primitive array assignment operation. Note that this instruction
  * 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();
   }
   String toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
   HInstruction get value => inputs[2];
@@ skipping 41 matching lines @@
   bool dataEquals(HIs other) {
     return typeExpression == other.typeExpression
         && nullOk == other.nullOk
         && kind == other.kind;
   }
 }
 
 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;
   }
 
   bool get isChecked => kind != NO_CHECK;
   bool get isCheckedModeCheck {
     return kind == CHECKED_MODE_CHECK
         || 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;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
 
   bool dataEquals(HTypeConversion other) {
     return kind == other.kind
         && typeExpression == other.typeExpression
         && instructionType == other.instructionType;
   }
@@ skipping 372 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }