Implement is-checks against type variables.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 76 matching lines @@
 
   /**
    * Raw ClassElement symbols occuring in is-checks and type assertions.  If the
    * program contains parameterized checks `x is Set<int>` and
    * `x is Set<String>` then the ClassElement `Set` will occur once in
    * [checkedClasses].
    */
   Set<ClassElement> checkedClasses;
 
   /**
+   * Set of JS native classes (or 'Object') that need a [:$nativeCheck:] method,
+   * because they could be used as a type argument in an is-check.
+   *
+   * For example, in the following program, the class int needs a native check
+   * to correctly match integers in the is-check:
+   *   class Check<T> { foo(o) => o is T; }
+   *   main() => new Check<int>().foo(3);
+   */
+  Set<ClassElement> requiredNativeChecks;
+
+  /**
    * Raw Typedef symbols occuring in is-checks and type assertions.  If the
    * program contains `x is F<int>` and `x is F<bool>` then the TypedefElement
    * `F` will occur once in [checkedTypedefs].
    */
   Set<TypedefElement> checkedTypedefs;
 
   final bool generateSourceMap;
 
   CodeEmitterTask(Compiler compiler, Namer namer, this.generateSourceMap)
       : boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
         interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void computeRequiredTypeChecks() {
-    assert(checkedClasses == null);
+    assert(checkedClasses == null &&
+           checkedTypedefs == null &&
+           requiredNativeChecks == null);
+
+    // Compute type arguments of classes that potentially use their type
+    // variables in is-checks and compute the (small) set of classes that
+    // need native check methods (consult the documentation of
+    // [requiredNativeChecks] for more information).
+    requiredNativeChecks = new Set<ClassElement>();
+    Link<ClassElement> classes = compiler.world.classesUsingTypeVariableTests;
+    if (!classes.isEmpty) {
+      // Find all instantiated types that are a supertype of a class that uses

[ngeoffray, 2013/02/18 09:27:58]

supertype -> subtype?

[karlklose, 2013/02/18 16:02:01]

Done.

+      // one of its type arguments in an is-check and add the arguments to the
+      // set of is-checks.
+      for (DartType type in compiler.codegenWorld.instantiatedTypes) {
+        if (type.kind != TypeKind.INTERFACE) continue;
+        InterfaceType classType = type;
+        for (classes = compiler.world.classesUsingTypeVariableTests;

[ngeoffray, 2013/02/18 09:27:58]

Shouldn't that be in codegenWorld as well?

[karlklose, 2013/02/18 16:02:01]

This is in the shared world. I am not sure it is worth it to move it to
resolution and codegen universes.

[ngeoffray, 2013/02/19 09:00:41]

Why not? The codegen world will have less or equal number of classes using type
variable tests.

[karlklose, 2013/02/19 12:39:28]

Moved to the backend.

+             !classes.isEmpty;
+             classes = classes.tail) {
+          // We need the type as instance of its superclass anyway, so we just
+          // try to compute the substitution; if the result is [:null:], the
+          // classes are not related.
+          InterfaceType instance = classType.asInstanceOf(classes.head);
+          if (instance == null) continue;
+          Link<DartType> typeArguments = instance.typeArguments;
+          for (DartType argument in typeArguments) {
+            Element element = argument.element;
+            JavaScriptBackend backend = compiler.backend;
+            if (backend.rti.needsNativeCheck(element)) {
+              requiredNativeChecks.add(element);
+            }
+            compiler.codegenWorld.isChecks.add(argument);
+          }
+        }
+      }
+    }
+
     checkedClasses = new Set<ClassElement>();
     checkedTypedefs = new Set<TypedefElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) {
         checkedClasses.add(t.element);
       } else if (t is TypedefType) {
         checkedTypedefs.add(t.element);
       }
     });
   }
@@ skipping 654 matching lines @@
           includeSuperMembers: false);
     });
 
     classElement.implementation.forEachMember(
         visitMember,
         includeBackendMembers: true,
         includeSuperMembers: false);
 
     void generateIsTest(Element other) {
       js.Expression code;
-      if (compiler.objectClass == other) return;
+      if (other == compiler.objectClass && classElement != other) return;

[ngeoffray, 2013/02/18 09:27:58]

Why this change? It looks like you're getting rid of $isA on the A class.

[karlklose, 2013/02/18 16:02:01]

We may need the $isObject flag on objects now, when a type A<Object> tests
against its type variable. This installs Object.$isObject, if it is necessary,
but returns for C.$isObject for all classes C != Object.

[ngeoffray, 2013/02/19 09:00:41]

So why did you remove it in the new version of the CL?

       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = js.fun([], js.block1(js.return_(new js.LiteralBool(true))));
       } else {
         code = new js.LiteralBool(true);
       }
       builder.addProperty(namer.operatorIs(other), code);
     }
 
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypeInformation rti = backend.rti;
@@ skipping 41 matching lines @@
       String name = backend.namer.publicInstanceMethodNameByArity(
           const SourceString('=='), 1);
       Function kind = (classElement == backend.jsNullClass)
           ? js.equals
           : js.strictEquals;
       builder.addProperty(name, js.fun(['receiver', 'a'],
           js.block1(js.return_(kind(js.use('receiver'), js.use('a'))))));
     }
   }
 
   void emitRuntimeClassesAndTests(CodeBuffer buffer) {

[ngeoffray, 2013/02/18 09:27:58]

should that be called emitRuntimeTypesAndTests? What's a runtime class?

[karlklose, 2013/02/18 16:02:01]

Initially I called the holder object runtime-classes. Would
'emitRuntimeTypeSupport' be better?

[ngeoffray, 2013/02/19 09:00:41]

+1

     JavaScriptBackend backend = compiler.backend;
     RuntimeTypeInformation rti = backend.rti;
     TypeChecks typeChecks = rti.getRequiredChecks();
 
     bool needsHolder(ClassElement cls) {
       return !neededClasses.contains(cls) || cls.isNative() ||
           rti.isJsNative(cls);
     }
 
     /**
      * Generates a holder object if it is needed.  A holder is a JavaScript
      * object literal with a field [builtin$cls] that contains the name of the
      * class as a string (just like object constructors do).  The is-checks for
      * the class are are added to the holder object later.
      */
     void maybeGenerateHolder(ClassElement cls) {
       if (!needsHolder(cls)) return;
       String holder = namer.isolateAccess(cls);
       String name = namer.getName(cls);
-      buffer.add("$holder$_=$_{builtin\$cls:$_'$name'");
-      buffer.add('}$N');
+      buffer.add("$holder$_=$_{builtin\$cls:$_'$name'}$N");
     }
 
     // Create representation objects for classes that we do not have a class
     // definition for (because they are uninstantiated or native).
     for (ClassElement cls in rti.allArguments) {
       maybeGenerateHolder(cls);
     }
 
     // Add checks to the constructors of instantiated classes or to the created
     // holder object.
     for (ClassElement cls in typeChecks) {
       String holder = namer.isolateAccess(cls);
       for (ClassElement check in typeChecks[cls]) {
         buffer.add('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
           buffer.add('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
         }
       };
     }
+
+    // Emit native check methods for the class representations of native types
+    // that could be used in an is-check against a type variable.
+    requiredNativeChecks.forEach((ClassElement cls) {
+      js.Expression nativeCheck = rti.getNativeCheck(cls);
+      String holder = namer.isolateAccess(cls);
+      buffer.add('$holder.${rti.getNativeCheckName()}$_=$_');
+      buffer.addBuffer(js.prettyPrint(nativeCheck, compiler));
+      buffer.add('$N');
+    });
   }
 
   void visitNativeMixins(ClassElement classElement,
                          void visit(MixinApplicationElement mixinApplication)) {
     if (!classElement.isNative()) return;
     // Use recursion to make sure to visit the superclasses before the
     // subclasses. Once we start keeping track of the emitted fields
     // and members, we're going to want to visit these in the other
     // order so we get the most specialized definition first.
     void recurse(ClassElement cls) {
@@ skipping 1529 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;