Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/js_backend/runtime_types.dart

 // Copyright (c) 2013, 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.backend;
 
 /// For each class, stores the possible class subtype tests that could succeed.
 abstract class TypeChecks {
   /// Get the set of checks required for class [element].
   Iterable<TypeCheck> operator [](ClassElement element);
@@ skipping 16 matching lines @@
   /// to get the runtime type.
   Iterable<ClassElement> get classesUsingTypeVariableExpression;
 
   void registerClassUsingTypeVariableExpression(ClassElement cls);
   void registerRtiDependency(Element element, Element dependency);
   void registerTypeVariableBoundsSubtypeCheck(
       DartType typeArgument, DartType bound);
 
   Set<ClassElement> getClassesUsedInSubstitutions(
       JavaScriptBackend backend, TypeChecks checks);
-  void computeClassesNeedingRti();
+  void computeClassesNeedingRti(
+      ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld);
 
   /// Compute the required type checkes and substitutions for the given
   /// instantitated and checked classes.
   TypeChecks computeChecks(
       Set<ClassElement> instantiated, Set<ClassElement> checked);
 
   /// Compute type arguments of classes that use one of their type variables in
   /// is-checks and add the is-checks that they imply.
   ///
   /// This function must be called after all is-checks have been registered.
@@ skipping 159 matching lines @@
               universe.registerIsCheck(argument);
             }
             current = current.element.supertype;
           } while (current != null && !instantiatedTypes.contains(current));
         }
       }
     }
   }
 
   @override
-  void computeClassesNeedingRti() {
+  void computeClassesNeedingRti(
+      ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld) {
     // Find the classes that need runtime type information. Such
     // classes are:
     // (1) used in a is check with type variables,
     // (2) dependencies of classes in (1),
     // (3) subclasses of (2) and (3).
     void potentiallyAddForRti(ClassElement cls) {
       assert(invariant(cls, cls.isDeclaration));
       if (cls.typeVariables.isEmpty) return;
       if (classesNeedingRti.contains(cls)) return;
       classesNeedingRti.add(cls);
 
       // TODO(ngeoffray): This should use subclasses, not subtypes.
-      compiler.closedWorld.forEachStrictSubtypeOf(cls, (ClassElement sub) {
+      closedWorld.forEachStrictSubtypeOf(cls, (ClassElement sub) {
         potentiallyAddForRti(sub);
       });
 
       Set<ClassElement> dependencies = rtiDependencies[cls];
       if (dependencies != null) {
         dependencies.forEach((ClassElement other) {
           potentiallyAddForRti(other);
         });
       }
     }
 
     Set<ClassElement> classesUsingTypeVariableTests = new Set<ClassElement>();
-    compiler.resolverWorld.isChecks.forEach((DartType type) {
+    resolverWorld.isChecks.forEach((DartType type) {
       if (type.isTypeVariable) {
         TypeVariableElement variable = type.element;
         // GENERIC_METHODS: When generic method support is complete enough to
         // include a runtime value for method type variables, this may need to
         // be updated: It simply ignores method type arguments.
         if (variable.typeDeclaration is ClassElement) {
           classesUsingTypeVariableTests.add(variable.typeDeclaration);
         }
       }
     });
@@ skipping 780 matching lines @@
  * substition for this check.
  */
 class TypeCheck {
   final ClassElement cls;
   final Substitution substitution;
   final int hashCode = _nextHash = (_nextHash + 100003).toUnsigned(30);
   static int _nextHash = 0;
 
   TypeCheck(this.cls, this.substitution);
 }