- Introduce the notion of setter constraints in the type inferrer, where we record things like: fie…

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 126 matching lines @@
 
   UnaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitNot;
   }
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     if (input == instruction.inputs[1]) {
       HType propagatedType = instruction.instructionType;
-      if (propagatedType.isUnknown() || propagatedType.isNumber()) {
+      if (propagatedType.canBePrimitiveNumber(compiler)) {
         return HType.INTEGER;
       }
     }
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
@@ skipping 17 matching lines @@
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     if (input == instruction.inputs[1]) {
       HType propagatedType = instruction.instructionType;
       // If the outgoing type should be a number (integer, double or both) we
       // want the outgoing type to be the input too.
       // If we don't know the outgoing type we try to make it a number.
       if (propagatedType.isNumber()) return propagatedType;
-      if (propagatedType.isUnknown()) return HType.NUMBER;
+      if (propagatedType.canBePrimitiveNumber(compiler)) return HType.NUMBER;
     }
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HInvokeDynamic instruction,
                                   Compiler compiler) {
     HType operandType = instruction.inputs[1].instructionType;
     if (operandType.isNumber()) return operandType;
     return instruction.instructionType;
   }
@@ skipping 25 matching lines @@
                                    Compiler compiler) {
     if (input == instruction.inputs[0]) return HType.UNKNOWN;
 
     HType propagatedType = instruction.instructionType;
     // If the desired output type should be an integer we want to get two
     // integers as arguments.
     if (propagatedType.isInteger()) return HType.INTEGER;
     // If the outgoing type should be a number we can get that if both inputs
     // are numbers. If we don't know the outgoing type we try to make it a
     // number.
-    if (propagatedType.isUnknown() || propagatedType.isNumber()) {
+    if (propagatedType.canBePrimitiveNumber(compiler)) {
       return HType.NUMBER;
     }
     // Even if the desired outgoing type is not a number we still want the
     // second argument to be a number if the first one is a number. This will
     // not help for the outgoing type, but at least the binary arithmetic
     // operation will not have type problems.
     // TODO(floitsch): normally we shouldn't request a number, but simply
     // throw an ArgumentError if it isn't. This would be similar
     // to the array case.
     HInstruction left = instruction.inputs[1];
@@ skipping 129 matching lines @@
   }
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     if (input == instruction.inputs[0]) return HType.UNKNOWN;
     HType propagatedType = instruction.instructionType;
     // If the outgoing type should be a number we can get that only if both
     // inputs are integers. If we don't know the outgoing type we try to make
     // it an integer.
-    if (propagatedType.isUnknown() || propagatedType.isNumber()) {
+    if (propagatedType.canBePrimitiveNumber(compiler)) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 }
 
 class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
   const ShiftLeftSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
@@ skipping 79 matching lines @@
   }
 
   HType computeDesiredTypeForInput(HInvokeDynamic instruction,
                                    HInstruction input,
                                    Compiler compiler) {
     if (input == instruction.inputs[0]) return HType.UNKNOWN;
     HType propagatedType = instruction.instructionType;
     // For all relational operations except HIdentity, we expect to get numbers
     // only. With numbers the outgoing type is a boolean. If something else
     // is desired, then numbers are incorrect, though.
-    if (propagatedType.isUnknown() || propagatedType.isBoolean()) {
+    if (propagatedType.canBePrimitiveBoolean(compiler)) {
       HInstruction left = instruction.inputs[1];
       if (left.instructionType.canBePrimitiveNumber(compiler)) {
         return HType.NUMBER;
       }
     }
     return HType.UNKNOWN;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction) {
     HInstruction left = instruction.inputs[1];
@@ skipping 94 matching lines @@
   const LessEqualSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.lessEqual;
   }
 
   HInstruction newBuiltinVariant(HInstruction left, HInstruction right) {
     return new HLessEqual(left, right);
   }
 }