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 81 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;
 
+  Iterable<ClassElement> cachedClassesUsingTypeVariableTests;
+
+  Iterable<ClassElement> get classesUsingTypeVariableTests {
+    if (cachedClassesUsingTypeVariableTests == null) {
+      cachedClassesUsingTypeVariableTests = backend.rti.isChecks
+          .where((DartType t) => t is TypeVariableType)
+          .map((TypeVariableType v) => v.element.getEnclosingClass());
+    }
+    return cachedClassesUsingTypeVariableTests;
+  }
+
   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>();
+    Iterable<ClassElement> classes = classesUsingTypeVariableTests;
+    if (!classes.isEmpty) {
+      // Find all instantiated types that are a subtype of a class that uses
+      // one of its type arguments in an is-check and add the arguments to the
+      // set of is-checks.
+      // TODO(karlklose): replace this with code that uses a subtype lookup
+      // datastructure in the world.
+      for (DartType type in compiler.codegenWorld.instantiatedTypes) {
+        if (type.kind != TypeKind.INTERFACE) continue;
+        InterfaceType classType = type;
+        for (ClassElement cls in classes) {
+          // 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(cls);
+          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 935 matching lines @@
           includeSuperMembers: false);
     });
 
     classElement.implementation.forEachMember(
         visitMember,
         includeBackendMembers: true,
         includeSuperMembers: false);
 
     void generateIsTest(Element other) {
       jsAst.Expression code;
-      if (compiler.objectClass == other) return;
+      if (other == compiler.objectClass) return;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = js.fun([], [js.return_(true)]);
       } else {
         code = new jsAst.LiteralBool(true);
       }
       builder.addProperty(namer.operatorIs(other), code);
     }
 
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypeInformation rti = backend.rti;
@@ skipping 40 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.block(js.return_(kind(js['receiver'], js['a'])))));
     }
   }
 
-  void emitRuntimeClassesAndTests(CodeBuffer buffer) {
+  void emitRuntimeTypeSupport(CodeBuffer buffer) {
     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) {
+      jsAst.Expression nativeCheck = rti.getNativeCheck(cls);
+      String holder = namer.isolateAccess(cls);
+      buffer.add('$holder.${namer.getNativeCheckName()}$_=$_');
+      buffer.addBuffer(jsAst.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 368 matching lines @@
       // substitutions for all checks and make emitSubstitution a NOP for the
       // rest of this function.
       Set<ClassElement> emitted = new Set<ClassElement>();
       // TODO(karlklose): move the computation of these checks to
       // RuntimeTypeInformation.
       if (compiler.world.needsRti(cls)) {
         emitSubstitution(superclass, emitNull: true);
         emitted.add(superclass);
       }
       for (DartType supertype in cls.allSupertypes) {
+        ClassElement superclass = supertype.element;
+        if (classesUsingTypeVariableTests.contains(superclass)) {
+          emitSubstitution(superclass, emitNull: true);
+          emitted.add(superclass);
+        }
         for (ClassElement check in checkedClasses) {
           if (supertype.element == check && !emitted.contains(check)) {
             // Generate substitution.  If no substitution is necessary, emit
             // [:null:] to overwrite a (possibly) existing substitution from the
             // super classes.
             emitSubstitution(check, emitNull: true);
             emitted.add(check);
           }
         }
       }
@@ skipping 997 matching lines @@
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
     buffer.add(jsAst.prettyPrint(decl, compiler).getText());
   }
 
   String assembleProgram() {
     measure(() {
       computeNeededClasses();
-
       mainBuffer.add(GENERATED_BY);
       if (!compiler.enableMinification) mainBuffer.add(HOOKS_API_USAGE);
       mainBuffer.add('function ${namer.isolateName}()$_{}\n');
       mainBuffer.add('init()$N$n');
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector$_=$_{}$N');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add(
           'var $isolateProperties$_=$_$isolatePropertiesName$N');
       emitClasses(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       // Clear the buffer, so that we can reuse it for the native classes.
       boundClosureBuffer.clear();
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
       // We need to finish the classes before we construct compile time
       // constants.
       emitFinishClassesInvocationIfNecessary(mainBuffer);
-      emitRuntimeClassesAndTests(mainBuffer);
+      emitRuntimeTypeSupport(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitOneShotInterceptors(mainBuffer);
       emitGetInterceptorMethods(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
@@ skipping 59 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].
 """;