Collect the types used in is-checks in the resolver phase.

lib/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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 2154 matching lines @@
 
   void checkFixedArray(HInstruction input) {
     checkFieldExists(input, 'fixed\$length');
   }
 
   void checkNull(HInstruction input) {
     use(input);
     push(new js.Binary('==', pop(), new js.LiteralNull()));
   }
 
-  void checkFunction(HInstruction input, Element element) {
+  void checkFunction(HInstruction input, Type type) {
     checkTypeOf(input, '===', 'function');
     js.Expression functionTest = pop();
     checkObject(input, '===');
     js.Expression objectTest = pop();
-    checkType(input, element);
+    checkType(input, type);
     push(new js.Binary('||',
                        functionTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
-  void checkType(HInstruction input, Element element, [bool negative = false]) {
-    world.registerIsCheck(element);
+  void checkType(HInstruction input, Type type, [bool negative = false]) {
+    Element element = type.element;
     use(input);
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), compiler.namer.operatorIs(element));
     if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
       push(new js.Prefix('!', field));
       // If the result is not negated, put another '!' in front.
       if (!negative) push(new js.Prefix('!', pop()));
     }
   }
 
-  void handleStringSupertypeCheck(HInstruction input, Element element) {
+  void handleStringSupertypeCheck(HInstruction input, Type type) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for List too.
-    assert(element !== compiler.listClass
-           && !Elements.isListSupertype(element, compiler));
+    assert(type.element !== compiler.listClass
+           && !Elements.isListSupertype(type.element, compiler));
     checkString(input, '===');
     js.Expression stringTest = pop();
     checkObject(input, '===');
     js.Expression objectTest = pop();
-    checkType(input, element);
+    checkType(input, type);
     push(new js.Binary('||',
                        stringTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
-  void handleListOrSupertypeCheck(HInstruction input, Element element) {
+  void handleListOrSupertypeCheck(HInstruction input, Type type) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for String too.
-    assert(element !== compiler.stringClass
-           && !Elements.isStringSupertype(element, compiler));
+    assert(type.element !== compiler.stringClass
+           && !Elements.isStringSupertype(type.element, compiler));
     checkObject(input, '===');
     js.Expression objectTest = pop();
     checkArray(input, '===');
     js.Expression arrayTest = pop();
-    checkType(input, element);
+    checkType(input, type);
     push(new js.Binary('&&',
                        objectTest,
                        new js.Binary('||', arrayTest, pop())));
   }
 
   void visitIs(HIs node) {
     Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables", instruction: node);
@@ skipping 14 matching lines @@
     } else if (element == compiler.doubleClass) {
       checkDouble(input, '===');
       attachLocationToLast(node);
     } else if (element == compiler.numClass) {
       checkNum(input, '===');
       attachLocationToLast(node);
     } else if (element == compiler.boolClass) {
       checkBool(input, '===');
       attachLocationToLast(node);
     } else if (element == compiler.functionClass) {
-      checkFunction(input, element);
+      checkFunction(input, type);
       attachLocationToLast(node);
     } else if (element == compiler.intClass) {
       checkNum(input, '===');
       js.Expression numTest = pop();
       checkInt(input, '===');
       push(new js.Binary('&&', numTest, pop()), node);
     } else if (Elements.isStringSupertype(element, compiler)) {
-      handleStringSupertypeCheck(input, element);
+      handleStringSupertypeCheck(input, type);
       attachLocationToLast(node);
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
-      handleListOrSupertypeCheck(input, element);
+      handleListOrSupertypeCheck(input, type);
       attachLocationToLast(node);
     } else if (types[input].canBePrimitive() || types[input].canBeNull()) {
       checkObject(input, '===');
       js.Expression objectTest = pop();
-      checkType(input, element);
+      checkType(input, type);
       push(new js.Binary('&&', objectTest, pop()), node);
     } else {
-      checkType(input, element);
+      checkType(input, type);
       attachLocationToLast(node);
     }
     if (node.hasTypeInfo()) {
       InterfaceType interfaceType = type;
       ClassElement cls = type.element;
       Link<Type> arguments = interfaceType.arguments;
       js.Expression result = pop();
       for (TypeVariableType typeVariable in cls.typeVariables) {
         use(node.typeInfoCall);
         // TODO(johnniwinther): Retrieve the type name properly and not through
@@ skipping 37 matching lines @@
           const SourceString("listSuperNativeTypeCast"),
       "listSuperTypeCheck":
           const SourceString("listSuperTypeCast"),
       "callTypeCheck":
           const SourceString("callTypeCast"),
       "propertyTypeCheck":
           const SourceString("propertyTypeCast")
     };
 
     if (node.isChecked) {
-      Element element = node.type.computeType(compiler).element;
-      world.registerIsCheck(element);
+      Type type = node.type.computeType(compiler);
+      Element element = type.element;
       SourceString helper;
       String additionalArgument;
       bool nativeCheck =
           backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
 
       if (node.isArgumentTypeCheck) {
         if (element == compiler.intClass) {
           checkInt(node.checkedInput, '!==');
         } else {
           assert(element == compiler.numClass);
@@ skipping 122 matching lines @@
     } else {
       bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(element));
     }
     js.Call call = new js.Call(bailoutTarget, arguments);
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   void visitTypeGuard(HTypeGuard node) {
     HInstruction input = node.guarded;
-    Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
+    Type indexingBehavior =
+        compiler.jsIndexingBehaviorInterface.computeType(compiler);
     if (node.isInteger(types)) {
       // if (input is !int) bailout
       checkInt(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not an integer')),
                     node);
     } else if (node.isNumber(types)) {
       // if (input is !num) bailout
       checkNum(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not a number')), node);
     } else if (node.isBoolean(types)) {
@@ skipping 431 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }