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> cachedNeededClasses;
+  Set<ClassElement> cachedInstantiatedClasses;
 
   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'");

[ngeoffray, 2012/12/13 13:34:58]

I think you can share the following code with the one line 800 (that adds the
is$ properties to the holder), since holder is also a JS object.

[karlklose, 2012/12/13 14:37:34]

I want to generate the checks for the synthetic holder inline. I could create a
shared helper, but I find the result pretty unreadable.

+      for (ClassElement check in typeChecks[cls]) {
+        buffer.add(',${_}is\$${namer.getName(check)}:${_}true');

[ngeoffray, 2012/12/13 13:34:58]

Please use namer.operatorIs.

[karlklose, 2012/12/13 14:37:34]

Done.

+      };
+      buffer.add('}$N');
+    }
+
+    // Create representation objects for classes that we do not need a class

[ngeoffray, 2012/12/13 13:34:58]

do not need -> do not have

[karlklose, 2012/12/13 14:37:34]

Done.

+    // 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.is\$${namer.getName(check)} = true;\n');

[ngeoffray, 2012/12/13 13:34:58]

namer.operatorIs.

[karlklose, 2012/12/13 14:37:34]

Done.

+      };
+    }
+  }
+
   /**
    * 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 400 matching lines @@
     // Add unneeded interceptors to the [unneededClasses] set.
     for (ClassElement interceptor in backend.interceptedClasses.keys) {
       if (!needed.contains(interceptor)) {
         unneededClasses.add(interceptor);
       }
     }
 
     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> get instantiatedClasses {

[ngeoffray, 2012/12/13 13:34:58]

Do you need this? If it's only used by the neededClasses getter, I would inline
it.

[karlklose, 2012/12/13 14:37:34]

It is also needed in emitClasses.

+    if (cachedInstantiatedClasses != null) return cachedInstantiatedClasses;
+    cachedInstantiatedClasses =
+        compiler.codegenWorld.instantiatedClasses.filter(computeClassFilter());
+    return cachedInstantiatedClasses;
+  }
 
-    Set<ClassElement> instantiatedClasses =
-        compiler.codegenWorld.instantiatedClasses.filter(computeClassFilter());
+  /// Get or compute the classes that we need to emit.
+  Set<ClassElement> get neededClasses {

[ngeoffray, 2012/12/13 13:34:58]

Instead of doing this lazily I would definitely prefer that the emitter just
computes it when it starts. The set will always be computed anyways.

[karlklose, 2012/12/13 14:37:34]

Done.

+    if (cachedNeededClasses != null) return cachedNeededClasses;
 
-    Set<ClassElement> neededClasses =
-        new Set<ClassElement>.from(instantiatedClasses);
+    cachedNeededClasses = 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);
       }
     }
+
+    return cachedNeededClasses;
+  }
+
+  void emitClasses(CodeBuffer buffer) {
+    // Compute the required type checks to know which classes need a
+    // 'is$' method.
+    computeRequiredTypeChecks();
     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 745 matching lines @@
           '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].
 """;