Implement subtype checks on type arguments.

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 26 matching lines @@
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
+  Set<ClassElement> neededClasses;
+  Set<ClassElement> instantiatedClasses;

[ngeoffray, 2012/12/13 14:52:12]

Please add a TODO(ngeoffray): to remove this field.

[karlklose, 2012/12/13 14:56:45]

Done.

 
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
   /**
    * A cache of closures that are used to closurize instance methods.
    * A closure is dynamically bound to the instance used when
    * closurized.
    */
@@ skipping 693 matching lines @@
       // Emit the noSuchMethod handlers on the Object prototype now,
       // so that the code in the dynamicFunction helper can find
       // them. Note that this helper is invoked before analyzing the
       // full JS script.
       if (!nativeEmitter.handleNoSuchMethod) {
         emitNoSuchMethodHandlers(defineInstanceMember);
       }
     }
   }
 
+  void emitRuntimeClassesAndTests(CodeBuffer buffer) {
+    JavaScriptBackend backend = compiler.backend;
+    RuntimeTypeInformation rti = backend.rti;
+
+    TypeChecks typeChecks = rti.computeRequiredChecks();
+
+    bool needsHolder(ClassElement cls) {
+      return !neededClasses.contains(cls) || cls.isNative() ||
+          rti.isJsNative(cls);
+    }
+
+    void maybeGenerateHolder(ClassElement cls) {
+      if (!needsHolder(cls)) return;
+
+      String holder = namer.isolateAccess(cls);
+      String name = namer.getName(cls);
+      buffer.add("$holder$_=$_{builtin\$cls:$_'$name'");
+      for (ClassElement check in typeChecks[cls]) {
+        buffer.add(',$_${namer.operatorIs(check)}:${_}true');
+      };
+      buffer.add('}$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.
+    for (ClassElement cls in typeChecks) {
+      if (needsHolder(cls)) {
+        // We already emitted the is-checks in the object definition for this
+        // class.
+        continue;
+      }
+      String holder = namer.isolateAccess(cls);
+      for (ClassElement check in typeChecks[cls]) {
+        buffer.add('$holder.${namer.operatorIs(check)}$_=${_}true$N');
+      };
+    }
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
                         void addField(Element member,
                                       String name,
                                       String accessorName,
                                       bool needsGetter,
@@ skipping 404 matching lines @@
       }
     }
 
     return (ClassElement cls) => !unneededClasses.contains(cls);
   }
 
   void emitClasses(CodeBuffer buffer) {
     // Compute the required type checks to know which classes need a
     // 'is$' method.
     computeRequiredTypeChecks();
-
-    Set<ClassElement> instantiatedClasses =
-        compiler.codegenWorld.instantiatedClasses.filter(computeClassFilter());
-
-    Set<ClassElement> neededClasses =
-        new Set<ClassElement>.from(instantiatedClasses);
-
-    for (ClassElement element in instantiatedClasses) {
-      for (ClassElement superclass = element.superclass;
-           superclass != null;
-           superclass = superclass.superclass) {
-        if (neededClasses.contains(superclass)) break;
-        neededClasses.add(superclass);
-      }
-    }
     List<ClassElement> sortedClasses =
         new List<ClassElement>.from(neededClasses);
     sortedClasses.sort((ClassElement class1, ClassElement class2) {
       // We sort by the ids of the classes. There is no guarantee that these
       // ids are meaningful (or even deterministic), but in the current
       // implementation they are increasing within a source file.
       return class1.id - class2.id;
     });
 
     // If we need noSuchMethod support, we run through all needed
@@ skipping 723 matching lines @@
           for (ClassElement cls in classes) {
             if (compiler.codegenWorld.instantiatedClasses.contains(cls)) {
               buffer.add('\n$_$_');
               emitInterceptorCheck(cls, buffer);
             }
           }
           buffer.add('\n$_${_}return $objectName.prototype;$n}$N');
         });
   }
 
+  void computeNeededClasses() {
+    instantiatedClasses =
+        compiler.codegenWorld.instantiatedClasses.filter(computeClassFilter());
+    neededClasses = new Set<ClassElement>.from(instantiatedClasses);
+    for (ClassElement element in instantiatedClasses) {
+      for (ClassElement superclass = element.superclass;
+          superclass != null;
+          superclass = superclass.superclass) {
+        if (neededClasses.contains(superclass)) break;
+        neededClasses.add(superclass);
+      }
+    }
+  }
+
   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);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitGetInterceptorMethods(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
@@ skipping 45 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].
 """;