Fix selector name check, and make the interceptor participate in speculatively propagating types.

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 1337 matching lines @@
             ? HType.INDEXABLE_PRIMITIVE
             : HType.MUTABLE_ARRAY;
       }
       // The index should be an int when the receiver is a string or array.
       // However it turns out that inserting an integer check in the optimized
       // version is cheaper than having another bailout case. This is true,
       // because the integer check will simply throw if it fails.
       return HType.UNKNOWN;
     } else if (selector.kind == SelectorKind.OPERATOR) {
       HType propagatedType = types[this];
-      if (selector.name == const SourceString('-') && input == inputs[1]) {
+      if (selector.name == const SourceString('unary-') && input == inputs[1]) {
         // 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;
       } else if (selector.name == const SourceString('~')
                  && input == inputs[1]) {
         if (propagatedType.isUnknown() || propagatedType.isNumber()) {
           return HType.INTEGER;
         }
       }
       return HType.UNKNOWN;
     }
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     // TODO(ngeoffray): Move this logic into a different class that
     // will know what type it has for a given selector.
     if (!isInterceptorCall) return HType.UNKNOWN;
 
     if (selector.kind == SelectorKind.OPERATOR) {
-      if (selector.name == const SourceString('-')) {
+      if (selector.name == const SourceString('unary-')) {
         HType operandType = types[inputs[1]];
         if (operandType.isNumber()) return operandType;
       } else if (selector.name == const SourceString('~')) {
         // All bitwise operations on primitive types either produce an
         // integer or throw an error.
         if (inputs[1].isPrimitive(types)) return HType.INTEGER;
       }
     }
     return HType.UNKNOWN;
   }
@@ skipping 1004 matching lines @@
       : super(<HInstruction>[receiver]);
   String toString() => 'interceptor on $interceptedClasses';
   accept(HVisitor visitor) => visitor.visitInterceptor(this);
   HInstruction get receiver => inputs[0];
 
   void prepareGvn(HTypeMap types) {
     clearAllSideEffects();
     setUseGvn();
   }
 
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {

[ngeoffray, 2013/01/15 10:32:27]

This was the main reason for the unit test to fail: the unit test was looking
for a type guard, but since the interceptor did not say the type it wanted, the
type guard was not inserted. Before, a "-a" in Dart code that translates to the
SSA HNegate was always saying it wanted a number as input.

+    if (interceptedClasses.length != 1) return HType.UNKNOWN;
+    // If the only class being intercepted is of type number, we
+    // make this interceptor call say it wants that class as input.
+    Element interceptor = interceptedClasses.toList()[0];
+    JavaScriptBackend backend = compiler.backend;
+    if (interceptor == backend.jsNumberClass) {
+      return HType.NUMBER;
+    } else if (interceptor == backend.jsIntClass) {
+      return HType.INTEGER;
+    } else if (interceptor == backend.jsDoubleClass) {
+      return HType.DOUBLE;
+    }
+    return HType.UNKNOWN;
+  }
+
   int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInterceptor;
   bool dataEquals(HInterceptor other) {
     return interceptedClasses == other.interceptedClasses
         || (interceptedClasses.length == other.interceptedClasses.length
             && interceptedClasses.containsAll(other.interceptedClasses));
   }
 }
 
 /** An [HLazyStatic] is a static that is initialized lazily at first read. */
@@ skipping 499 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);
 }