Rename Universe to WorldBuilder.

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 28 matching lines @@
   /// 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.
   void addImplicitChecks(
-      Universe universe, Iterable<ClassElement> classesUsingChecks);
+      WorldBuilder universe, Iterable<ClassElement> classesUsingChecks);
 
   /// Return all classes that are referenced in the type of the function, i.e.,
   /// in the return type or the argument types.
   Set<ClassElement> getReferencedClasses(FunctionType type);
 
   /// Return all classes that are uses a type arguments.
   Set<ClassElement> getRequiredArgumentClasses(JavaScriptBackend backend);
 
   bool isTrivialSubstitution(ClassElement cls, ClassElement check);
 
@@ skipping 103 matching lines @@
    * 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.
    *
    * TODO(karlklose): move these computations into a function producing an
    * immutable datastructure.
    */
   @override
   void addImplicitChecks(
-      Universe universe, Iterable<ClassElement> classesUsingChecks) {
+      WorldBuilder universe, Iterable<ClassElement> classesUsingChecks) {
     // If there are no classes that use their variables in checks, there is
     // nothing to do.
     if (classesUsingChecks.isEmpty) return;
     Set<DartType> instantiatedTypes = universe.instantiatedTypes;
     if (cannotDetermineInstantiatedTypesPrecisely) {
       for (DartType type in instantiatedTypes) {
         if (type.kind != TypeKind.INTERFACE) continue;
         InterfaceType interface = type;
         do {
           for (DartType argument in interface.typeArguments) {
@@ skipping 173 matching lines @@
     Set<DartType> isChecks = compiler.codegenWorld.isChecks;
     // These types are needed for is-checks against function types.
     Set<DartType> instantiatedTypesAndClosures =
         computeInstantiatedTypesAndClosures(compiler.codegenWorld);
     computeInstantiatedArguments(instantiatedTypesAndClosures, isChecks);
     computeCheckedArguments(instantiatedTypesAndClosures, isChecks);
     cachedRequiredChecks =
         computeChecks(allInstantiatedArguments, checkedArguments);
   }
 
-  Set<DartType> computeInstantiatedTypesAndClosures(CodegenUniverse universe) {
+  Set<DartType> computeInstantiatedTypesAndClosures(
+      CodegenWorldBuilder universe) {
     Set<DartType> instantiatedTypes =
         new Set<DartType>.from(universe.instantiatedTypes);
     for (DartType instantiatedType in universe.instantiatedTypes) {
       if (instantiatedType.isInterfaceType) {
         InterfaceType interface = instantiatedType;
         FunctionType callType = interface.callType;
         if (callType != null) {
           instantiatedTypes.add(callType);
         }
       }
@@ skipping 655 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);
 }