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

sdk/lib/_internal/compiler/implementation/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2388 matching lines @@
       if (negative) {
         checkNonNull(input);
         push(new js.Binary('&&', pop(), pop()), node);
       } else {
         checkNull(input);
         push(new js.Binary('||', pop(), pop()), node);
       }
     }
   }
 
+  js.Expression generateTest(HCheck node) {
+    HInstruction input = node.checkedInput;
+    DartType indexingBehavior =
+        backend.jsIndexingBehaviorInterface.computeType(compiler);
+    js.Expression test;
+    if (node.isInteger()) {
+      // input is !int
+      checkInt(input, '!==');
+      test = pop();
+    } else if (node.isNumber()) {
+      // input is !num
+      checkNum(input, '!==');
+      test = pop();
+    } else if (node.isBoolean()) {
+      // input is !bool
+      checkBool(input, '!==');
+      test = pop();
+    } else if (node.isString()) {
+      // input is !string
+      checkString(input, '!==');
+      test = pop();
+    } else if (node.isExtendableArray()) {
+      // input is !Object || input is !Array || input.isFixed
+      checkObject(input, '!==');
+      js.Expression objectTest = pop();
+      checkArray(input, '!==');
+      js.Expression arrayTest = pop();
+      checkFixedArray(input);
+      test = new js.Binary('||', objectTest, arrayTest);
+      test = new js.Binary('||', test, pop());
+    } else if (node.isMutableArray()) {
+      // input is !Object
+      // || ((input is !Array || input.isImmutable)
+      //     && input is !JsIndexingBehavior)
+      checkObject(input, '!==');
+      js.Expression objectTest = pop();
+      checkArray(input, '!==');
+      js.Expression arrayTest = pop();
+      checkImmutableArray(input);
+      js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
+      checkType(input, indexingBehavior, negative: true);
+      js.Binary notIndexing = new js.Binary('&&', notArrayOrImmutable, pop());
+      test = new js.Binary('||', objectTest, notIndexing);
+    } else if (node.isReadableArray()) {
+      // input is !Object
+      // || (input is !Array && input is !JsIndexingBehavior)
+      checkObject(input, '!==');
+      js.Expression objectTest = pop();
+      checkArray(input, '!==');
+      js.Expression arrayTest = pop();
+      checkType(input, indexingBehavior, negative: true);
+      js.Expression notIndexing = new js.Binary('&&', arrayTest, pop());
+      test = new js.Binary('||', objectTest, notIndexing);
+    } else if (node.isIndexablePrimitive()) {
+      // input is !String
+      // && (input is !Object
+      //     || (input is !Array && input is !JsIndexingBehavior))
+      checkString(input, '!==');
+      js.Expression stringTest = pop();
+      checkObject(input, '!==');
+      js.Expression objectTest = pop();
+      checkArray(input, '!==');
+      js.Expression arrayTest = pop();
+      checkType(input, indexingBehavior, negative: true);
+      js.Binary notIndexingTest = new js.Binary('&&', arrayTest, pop());
+      js.Binary notObjectOrIndexingTest =
+          new js.Binary('||', objectTest, notIndexingTest);
+      test = new js.Binary('&&', stringTest, notObjectOrIndexingTest);
+    } else {
+      compiler.internalError('Unexpected type guard', instruction: input);
+    }
+    return test;
+  }
+
   void visitTypeConversion(HTypeConversion node) {
     if (node.isChecked) {
-      if (node.isArgumentTypeCheck) {
-        if (node.isInteger()) {
-          checkInt(node.checkedInput, '!==');
-        } else {
-          assert(node.isNumber());
-          checkNum(node.checkedInput, '!==');
-        }
-        js.Expression test = pop();
+      if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
+        js.Expression test = generateTest(node);
         js.Block oldContainer = currentContainer;
         js.Statement body = new js.Block.empty();
         currentContainer = body;
-        generateThrowWithHelper('iae', node.checkedInput);
+        if (node.isArgumentTypeCheck) {
+          generateThrowWithHelper('iae', node.checkedInput);
+        } else if (node.isReceiverTypeCheck) {
+          use(node.checkedInput);
+          String methodName =
+              backend.namer.invocationName(node.receiverTypeCheckSelector);
+          js.Expression call = jsPropertyCall(pop(), methodName, []);
+          pushStatement(new js.Throw(call));
+        }
         currentContainer = oldContainer;
         body = unwrapStatement(body);
         pushStatement(new js.If.noElse(test, body), node);
         return;
       }
 
       assert(node.isCheckedModeCheck || node.isCastTypeCheck);
       DartType type = node.typeExpression;
       world.registerIsCheck(type, work.resolutionTree);
 
@@ skipping 48 matching lines @@
   SsaOptimizedCodeGenerator(backend, work) : super(backend, work);
 
   HBasicBlock beginGraph(HGraph graph) {
     return graph.entry;
   }
 
   void endGraph(HGraph graph) {}
 
   // Called by visitTypeGuard to generate the actual bailout call, something
   // like "return $.foo$bailout(t0, t1);"
-  js.Statement bailout(HTypeGuard guard, String reason) {
+  js.Statement bailout(HTypeGuard guard) {
     HBailoutTarget target = guard.bailoutTarget;
     List<js.Expression> arguments = <js.Expression>[];
     arguments.add(new js.LiteralNumber("${guard.state}"));
 
     for (int i = 0; i < target.inputs.length; i++) {
       HInstruction parameter = target.inputs[i];
       for (int pad = target.padding[i]; pad != 0; pad--) {
         // This argument will not be used by the bailout function, because
         // of the control flow (controlled by the state argument passed
         // above).  We need to pass it to get later arguments in the right
@@ skipping 20 matching lines @@
       bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(method));
     }
     js.Call call = new js.Call(bailoutTarget, arguments);
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   // Generate a type guard, something like "if (typeof t0 == 'number')" and the
   // corresponding bailout call, something like "return $.foo$bailout(t0, t1);"
   void visitTypeGuard(HTypeGuard node) {
-    HInstruction input = node.guarded;
-    DartType indexingBehavior =
-        backend.jsIndexingBehaviorInterface.computeType(compiler);
-    String message;
-    js.Expression test;
-    if (node.isInteger()) {
-      // if (input is !int) bailout
-      checkInt(input, '!==');
-      test = pop();
-      message = 'Not an integer';
-    } else if (node.isNumber()) {
-      // if (input is !num) bailout
-      checkNum(input, '!==');
-      test = pop();
-      message = 'Not a number';
-    } else if (node.isBoolean()) {
-      // if (input is !bool) bailout
-      checkBool(input, '!==');
-      test = pop();
-      message = 'Not a boolean';
-    } else if (node.isString()) {
-      // if (input is !string) bailout
-      checkString(input, '!==');
-      test = pop();
-      message = 'Not a string';
-    } else if (node.isExtendableArray()) {
-      // if (input is !Object || input is !Array || input.isFixed) bailout
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkFixedArray(input);
-      test = new js.Binary('||', objectTest, arrayTest);
-      test = new js.Binary('||', test, pop());
-      message = 'Not an extendable array';
-    } else if (node.isMutableArray()) {
-      // if (input is !Object
-      //     || ((input is !Array || input.isImmutable)
-      //         && input is !JsIndexingBehavior)) bailout
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkImmutableArray(input);
-      js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
-      checkType(input, indexingBehavior, negative: true);
-      js.Binary notIndexing = new js.Binary('&&', notArrayOrImmutable, pop());
-      test = new js.Binary('||', objectTest, notIndexing);
-      message = 'Not a mutable array';
-    } else if (node.isReadableArray()) {
-      // if (input is !Object
-      //     || (input is !Array && input is !JsIndexingBehavior)) bailout
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkType(input, indexingBehavior, negative: true);
-      js.Expression notIndexing = new js.Binary('&&', arrayTest, pop());
-      test = new js.Binary('||', objectTest, notIndexing);
-      message = 'Not an array';
-    } else if (node.isIndexablePrimitive()) {
-      // if (input is !String
-      //     && (input is !Object
-      //         || (input is !Array && input is !JsIndexingBehavior))) bailout
-      checkString(input, '!==');
-      js.Expression stringTest = pop();
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkType(input, indexingBehavior, negative: true);
-      js.Binary notIndexingTest = new js.Binary('&&', arrayTest, pop());
-      js.Binary notObjectOrIndexingTest =
-          new js.Binary('||', objectTest, notIndexingTest);
-      test = new js.Binary('&&', stringTest, notObjectOrIndexingTest);
-      message = 'Not a string or array';
-    } else {
-      compiler.internalError('Unexpected type guard', instruction: input);
-    }
-    pushStatement(new js.If.noElse(test, bailout(node, message)), node);
+    js.Expression test = generateTest(node);
+    pushStatement(new js.If.noElse(test, bailout(node)), node);
   }
 
   void visitBailoutTarget(HBailoutTarget target) {
     // Do nothing. Bailout targets are only used in the non-optimized version.
   }
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
@@ skipping 370 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }