Change how we deal with manual inlining of argument error and NSM when propagating types. This chan…

sdk/lib/_internal/compiler/implementation/ssa/bailout.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 BailoutInfo {
   int instructionId;
   int bailoutId;
   BailoutInfo(this.instructionId, this.bailoutId);
@@ skipping 196 matching lines @@
           && typeGuardWouldBeValuable(user, speculativeType)) {
         return true;
       }
     }
 
     // Insert type guards if the method is likely to be called in a
     // loop.
     return calledInLoop;
   }
 
-  // Returns whether an invocation of [selector] on [receiver] will throw a
-  // [ArgumentError] if the argument is not of the right type.
-  bool willThrowArgumentError(Selector selector,
-                              HInstruction receiver,
-                              HType speculativeType) {
-    if (receiver != null
-        && (receiver.isInteger() || receiver.isString(compiler))) {
-      return selector.isOperator()
-          && selector.name != const SourceString('==')
-          && (speculativeType.isNumber() && !speculativeType.isInteger());
-    }
-    return false;
-  }
-
-  // Returns whether an invocation of [selector] will throw a
-  // [NoSuchMethodError] if the receiver is not of the type
-  // [speculativeType].
-  bool willThrowNoSuchMethodErrorIfNot(Selector selector,
-                                       HType speculativeType) {
-    return compiler.world.hasSingleMatch(selector)
-        // In some cases, we want the receiver to be an integer,
-        // but that does not mean we will get a NoSuchMethodError
-        // if it's not: the receiver could be a double.
-        && !speculativeType.isInteger()
-        // We speculate on the [operator==] instruction, but we know it
-        // will never throw a [NoSuchMethodError].
-        && selector.name != const SourceString('==');
-  }
-
-  bool shouldInsertTypeGuard(HInstruction instruction, HType speculativeType) {
-    if (!speculativeType.isUseful()) return false;
-    // If the types agree we don't need to check.
-    if (speculativeType == instruction.instructionType) return false;
-    // If a bailout check is more expensive than doing the actual operation
-    // don't do it either.
-    return typeGuardWouldBeValuable(instruction, speculativeType);
-  }
-
   HInstruction computeFirstDominatingUserWithSelector(
       HInstruction instruction) {
     // TODO(ngeoffray): We currently only look at the instruction's
     // block, so that we know it will be executed. We should lift this
     // limitation.
 
     // For a parameter, we look at the first block that contains
     // user instructions.
     HBasicBlock userMustBeInBlock = instruction is HParameterValue
         ? instruction.block.successors[0]
@@ skipping 11 matching lines @@
   }
 
   /**
    * Tries to insert a type conversion instruction for [instruction]
    * instead of a type guard if we know an user will throw. Returns
    * whether it succeeded at adding a type conversion instruction.
    */
   bool tryTypeConversion(HInstruction instruction, HType speculativeType) {
     HInstruction firstUser =
         computeFirstDominatingUserWithSelector(instruction);
-    if (firstUser == null) return false;
+    if (firstUser is !HInvokeDynamic) return false;
 
     // If we have found a user with a selector, we find out if it
-    // will throw [NoSuchMethodError] or [ArgumentError].
+    // will throw [NoSuchMethodError] or [ArgumentError]. If it does,
+    // then we change just add a [HTypeConversion] instruction and
+    // avoid a bailout.
     Selector selector = firstUser.selector;
-    Selector receiverSelectorOnThrow = null;
+    if (!selector.isOperator()) return false;
     HInstruction receiver = firstUser.getDartReceiver(compiler);
-    bool willThrow = false;
-    if (receiver == instruction) {
-      if (willThrowNoSuchMethodErrorIfNot(selector, speculativeType)) {
-        receiverSelectorOnThrow = selector;
-        willThrow = true;
-      }
-    // We need to call the actual method in checked mode to get
-    // the right type error.
-    } else if (!compiler.enableTypeAssertions
-               && willThrowArgumentError(selector, receiver, speculativeType)) {
-      willThrow = true;
+
+    if (instruction == receiver) {
+      // If the instruction on which we're speculating the
+      // type is the receiver of the call, check if it will throw
+      // [NoSuchMethodError] if [instruction] is not of the speculated
+      // type.
+      return checkReceiver(firstUser);
+    } else if (!selector.isUnaryOperator()
+               && instruction == firstUser.inputs[2]) {
+      // If the instruction is a parameter of the call, we check if
+      // the method will throw an [ArgumentError] if [instruction] is
+      // not of the speculated type.
+      return checkArgument(firstUser);
     }
-
-    if (!willThrow) return false;
-
-    HTypeConversion check = new HTypeConversion(
-            null,
-            receiverSelectorOnThrow == null
-                ? HTypeConversion.ARGUMENT_TYPE_CHECK
-                : HTypeConversion.RECEIVER_TYPE_CHECK,
-            speculativeType,
-            instruction,
-            receiverSelectorOnThrow);
-    hasInsertedChecks = true;
-    firstUser.block.addBefore(firstUser, check);
-    instruction.replaceAllUsersDominatedBy(firstUser, check);
-    return true;
+    return false;
   }
 
   bool updateType(HInstruction instruction) {
     bool hasChanged = super.updateType(instruction);
     HType speculativeType = savedTypes[instruction];
-    if (speculativeType == null) return hasChanged;
+    if (speculativeType == null
+        || !speculativeType.isUseful()
+        || speculativeType == instruction.instructionType) {
+      return hasChanged;
+    }
 
-    if (shouldInsertTypeGuard(instruction, speculativeType)
-        && !tryTypeConversion(instruction, speculativeType)) {
+    if (!tryTypeConversion(instruction, speculativeType)
+        && typeGuardWouldBeValuable(instruction, speculativeType)) {
       HInstruction insertionPoint;
       if (instruction is HPhi) {
         insertionPoint = instruction.block.first;
       } else if (instruction is HParameterValue) {
         // We insert the type guard at the end of the entry block
         // because if a parameter is live, it must be kept in the live
         // environment. Not doing so would mean we could visit a
         // parameter and remove it from the environment before
         // visiting a type guard.
         insertionPoint = instruction.block.last;
@@ skipping 405 matching lines @@
         hasComplexBailoutTargets = true;
       }
     } else {
       hasComplexBailoutTargets = true;
       blocks.forEach((HBasicBlock block) {
         block.bailoutTargets.add(target);
       });
     }
   }
 }