anchor.diff:  
         // If we found that we need number, we must still go through all
         // uses to check if they require int, or double.
  -      if (interceptedClasses.contains(backend.jsNumberClass)
  -          && !(interceptedClasses.contains(backend.jsDoubleClass)
  -               || interceptedClasses.contains(backend.jsIntClass))) {
  +      if (interceptedClasses.contains(backend.jsNumberClass) &&
  +          !(interceptedClasses.contains(backend.jsDoubleClass) ||
  +            interceptedClasses.contains(backend.jsIntClass))) {
           for (HInstruction user in node.usedBy) {
             if (user is! HInvoke) continue;
             Set<ClassElement> intercepted =
  
positive.code:     return false;
    }
  
    bool canUseSelfForInterceptor(HInstruction instruction,
                                  Set<ClassElement> interceptedClasses) {
      JavaScriptBackend backend = compiler.backend;
      if (instruction.canBePrimitive(compiler)) {
        // Primitives always need interceptors.
        return false;
      }
      if (instruction.canBeNull()
          && interceptedClasses.contains(backend.jsNullClass)) {
        // Need the JSNull interceptor.
        return false;
      }
  
      // [interceptedClasses] is sparse - it is just the classes that define some
      // intercepted method.  Their subclasses (that inherit the method) are
      // implicit, so we have to extend them.
      TypeMask receiverType = instruction.instructionType;
      return interceptedClasses
          .where((cls) => cls != compiler.objectClass)
          .map((cls) => backend.classesMixedIntoInterceptedClasses.contains(cls)
              ? new TypeMask.subtype(cls)
              : new TypeMask.subclass(cls))
          .every((mask) => receiverType.intersection(mask, compiler).isEmpty);
    }
  
    HInstruction tryComputeConstantInterceptor(
  
negative.code:       constantInterceptor = backend.jsStringClass;
      } else if (input.isArray(compiler)) {
        constantInterceptor = backend.jsArrayClass;
      } else if (input.isNumber(compiler) &&
          !interceptedClasses.contains(backend.jsIntClass) &&
          !interceptedClasses.contains(backend.jsDoubleClass)) {
        // If the method being intercepted is not defined in [int] or [double] we
        // can safely use the number interceptor.  This is because none of the
        // [int] or [double] methods are called from a method defined on [num].
  