dart2js: Make it more obvious how rti-only needed classes work.

pkg/compiler/lib/src/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 const USE_LAZY_EMITTER = const bool.fromEnvironment("dart2js.use.lazy.emitter");
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the `universe`.
  */
 class CodeEmitterTask extends CompilerTask {
   // TODO(floitsch): the code-emitter task should not need a namer.
   final Namer namer;
   final TypeTestRegistry typeTestRegistry;
   NativeEmitter nativeEmitter;
   MetadataCollector metadataCollector;
   OldEmitter oldEmitter;
   Emitter emitter;
 
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
+  Set<ClassElement> classesOnlyNeededForRti;
   final Map<OutputUnit, List<ClassElement>> outputClassLists =
       new Map<OutputUnit, List<ClassElement>>();
   final Map<OutputUnit, List<ConstantValue>> outputConstantLists =
       new Map<OutputUnit, List<ConstantValue>>();
   final Map<OutputUnit, List<Element>> outputStaticLists =
       new Map<OutputUnit, List<Element>>();
   final Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists =
       new Map<OutputUnit, List<VariableElement>>();
   final Map<OutputUnit, Set<LibraryElement>> outputLibraryLists =
       new Map<OutputUnit, Set<LibraryElement>>();
@@ skipping 169 matching lines @@
           if (shouldRetainMetadata &&
               (element.isFunction || element.isConstructor ||
                element.isSetter)) {
             FunctionElement function = element;
             function.functionSignature.forEachParameter(
                 backend.retainMetadataOf);
           }
         }
       }
       for (ClassElement cls in neededClasses) {
-        final onlyForRti = typeTestRegistry.rtiNeededClasses.contains(cls);
+        final onlyForRti = classesOnlyNeededForRti.contains(cls);
         if (!onlyForRti) {
           backend.retainMetadataOf(cls);
           oldEmitter.classEmitter.visitFields(cls, false,
               (Element member,
                jsAst.Name name,
                jsAst.Name accessorName,
                bool needsGetter,
                bool needsSetter,
                bool needsCheckedSetter) {
             bool needsAccessor = needsGetter || needsSetter;
@@ skipping 21 matching lines @@
         // some list constants. They are emitted in the main output-unit.
         // TODO(sigurdm): We should track those constants.
         constantUnit = compiler.deferredLoadTask.mainOutputUnit;
       }
       outputConstantLists.putIfAbsent(
           constantUnit, () => new List<ConstantValue>()).add(constant);
     }
   }
 
   /// Compute all the classes and typedefs that must be emitted.
-  void computeNeededDeclarations() {
+  void computeNeededDeclarations(Set<ClassElement> rtiNeededClasses) {
     // Compute needed typedefs.
     typedefsNeededForReflection = Elements.sortedByPosition(
         compiler.world.allTypedefs
             .where(backend.isAccessibleByReflection)
             .toList());
 
     // Compute needed classes.
     Set<ClassElement> instantiatedClasses =
         compiler.codegenWorld.directlyInstantiatedClasses
             .where(computeClassFilter()).toSet();
@@ skipping 23 matching lines @@
         .toSet();
     neededClasses.addAll(mixinClasses);
 
     // 3. Find all classes needed for rti.
     // It is important that this is the penultimate step, at this point,
     // neededClasses must only contain classes that have been resolved and
     // codegen'd. The rtiNeededClasses may contain additional classes, but
     // these are thought to not have been instantiated, so we neeed to be able
     // to identify them later and make sure we only emit "empty shells" without
     // fields, etc.
-    typeTestRegistry.computeRtiNeededClasses();
+    classesOnlyNeededForRti = rtiNeededClasses.difference(neededClasses);
 
-    // TODO(floitsch): either change the name, or get the rti-classes
-    // differently.
-    typeTestRegistry.rtiNeededClasses.removeAll(neededClasses);
-    // rtiNeededClasses now contains only the "empty shells".
-    neededClasses.addAll(typeTestRegistry.rtiNeededClasses);
+    neededClasses.addAll(classesOnlyNeededForRti);
 
     // TODO(18175, floitsch): remove once issue 18175 is fixed.
     if (neededClasses.contains(backend.jsIntClass)) {
       neededClasses.add(compiler.intClass);
     }
     if (neededClasses.contains(backend.jsDoubleClass)) {
       neededClasses.add(compiler.doubleClass);
     }
     if (neededClasses.contains(backend.jsNumberClass)) {
       neededClasses.add(compiler.numClass);
     }
     if (neededClasses.contains(backend.jsStringClass)) {
       neededClasses.add(compiler.stringClass);
     }
     if (neededClasses.contains(backend.jsBoolClass)) {
       neededClasses.add(compiler.boolClass);
     }
     if (neededClasses.contains(backend.jsArrayClass)) {
       neededClasses.add(compiler.listClass);
     }
 
     // 4. Finally, sort the classes.
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     for (ClassElement element in sortedClasses) {
       if (Elements.isNativeOrExtendsNative(element) &&
-          !typeTestRegistry.rtiNeededClasses.contains(element)) {
+          !classesOnlyNeededForRti.contains(element)) {
         // For now, native classes and related classes cannot be deferred.
         nativeClassesAndSubclasses.add(element);
         assert(invariant(element,
                          !compiler.deferredLoadTask.isDeferred(element)));
         outputClassLists.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
             () => new List<ClassElement>()).add(element);
       } else {
         outputClassLists.putIfAbsent(
             compiler.deferredLoadTask.outputUnitForElement(element),
             () => new List<ClassElement>())
@@ skipping 39 matching lines @@
     }
 
     backend.generatedCode.keys.forEach(addSurroundingLibraryToSet);
     neededClasses.forEach(addSurroundingLibraryToSet);
   }
 
   void computeAllNeededEntities() {
     // Compute the required type checks to know which classes need a
     // 'is$' method.
     typeTestRegistry.computeRequiredTypeChecks();
+    // Compute the classes needed by RTI.
+    Set<ClassElement> rtiClasses = typeTestRegistry.computeRtiNeededClasses();
 
-    computeNeededDeclarations();
+    computeNeededDeclarations(rtiClasses);
     computeNeededConstants();
     computeNeededStatics();
     computeNeededStaticNonFinalFields();
     computeNeededLibraries();
   }
 
   int assembleProgram() {
     return measure(() {
       emitter.invalidateCaches();
 
@@ skipping 48 matching lines @@
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant);
 
   /// Returns the JS code for accessing the given [constant].
   jsAst.Expression constantReference(ConstantValue constant);
 
   /// Returns the JS template for the given [builtin].
   jsAst.Template templateForBuiltin(JsBuiltin builtin);
 
   void invalidateCaches();
 }