Rename Universe to WorldBuilder.

pkg/compiler/lib/src/universe/world_builder.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.
 
 library universe;
 
 import 'dart:collection';
 
 import '../common.dart';
 import '../compiler.dart' show Compiler;
@@ skipping 69 matching lines @@
   ///
   ///     class A {}
   ///     class B { foo() {} }
   ///     m(b) => (b ? new A() : new B()).foo();
   ///
   /// the potential receiver `new A()` has no implementation of `foo` and thus
   /// needs to handle the call through its `noSuchMethod` handler.
   bool needsNoSuchMethodHandling(Selector selector, World world);
 }
 
-/// A mutable [SelectorConstraints] used in [Universe].
+/// A mutable [SelectorConstraints] used in [WorldBuilder].
 abstract class UniverseSelectorConstraints extends SelectorConstraints {
   /// Adds [constraint] to these selector constraints. Return `true` if the set
   /// of potential receivers expanded due to the new constraint.
   bool addReceiverConstraint(ReceiverConstraint constraint);
 }
 
 /// Strategy for computing the constraints on potential receivers of dynamic
 /// call sites.
 abstract class SelectorConstraintsStrategy {
   /// Create a [UniverseSelectorConstraints] to represent the global receiver
   /// constraints for dynamic call sites with [selector].
   UniverseSelectorConstraints createSelectorConstraints(Selector selector);
 }
 
-/// The [Universe] is an auxiliary class used in the process of computing the
-/// [ClosedWorld]. The concepts here and in [ClosedWorld] are very similar -- in
-/// the same way that the "universe expands" you can think of this as a mutable
-/// world that is expanding as we visit and discover parts of the program.
+/// The [WorldBuilder] is an auxiliary class used in the process of computing
+/// the [ClosedWorld]. The concepts here and in [ClosedWorld] are very similar

[Siggi Cherem (dart-lang), 2016/09/29 18:14:48]

nit: remove everything after the first sentence

+/// -- in the same way that the "universe expands" you can think of this as a
+/// mutable world that is expanding as we visit and discover parts of the
+/// program.
 // TODO(sigmund): rename to "growing/expanding/mutable world"?

[Siggi Cherem (dart-lang), 2016/09/29 18:14:48]

remove TODO :)

[Johnni Winther, 2016/09/30 08:43:14]

Done.

 // TODO(johnniwinther): Move common implementation to a [UniverseBase] when
 // universes and worlds have been unified.
-abstract class Universe {
+abstract class WorldBuilder {
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses;
 
   /// All types that are checked either through is, as or checked mode checks.
   Iterable<DartType> get isChecks;
 
   /// Registers that [type] is checked in this universe. The unaliased type is
   /// returned.
   DartType registerIsCheck(DartType type, Compiler compiler);
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<DartType> get instantiatedTypes;
 
   /// Returns `true` if [member] is invoked as a setter.
   bool hasInvokedSetter(Element member, World world);
 }
 
-abstract class ResolutionUniverse implements Universe {
+abstract class ResolutionWorldBuilder implements WorldBuilder {
   /// Set of (live) local functions (closures) whose signatures reference type
   /// variables.
   ///
   /// A live function is one whose enclosing member function has been enqueued.
   Set<Element> get closuresWithFreeTypeVariables;
 
   /// Set of (live) `call` methods whose signatures reference type variables.
   ///
   /// A live `call` method is one whose enclosing class has been instantiated.
   Iterable<Element> get callMethodsWithFreeTypeVariables;
 
   /// Set of all closures in the program. Used by the mirror tracking system
   /// to find all live closure instances.
   Iterable<LocalFunctionElement> get allClosures;
 
   /// Set of methods in instantiated classes that are potentially closurized.
   Iterable<Element> get closurizedMembers;
 
   /// Returns `true` if [cls] is considered to be implemented by an
   /// instantiated class, either directly, through subclasses or through
   /// subtypes. The latter case only contains spurious information from
   /// instantiations through factory constructors and mixins.
   bool isImplemented(ClassElement cls);
 
   /// Set of all fields that are statically known to be written to.
   Iterable<Element> get fieldSetters;
 }
 
-class ResolutionUniverseImpl implements ResolutionUniverse {
+class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
   final Set<ClassElement> _directlyInstantiatedClasses =
       new Set<ClassElement>();
 
@@ skipping 51 matching lines @@
   final Set<LocalFunctionElement> allClosures = new Set<LocalFunctionElement>();
 
   /**
    * Set of methods in instantiated classes that are potentially
    * closurized.
    */
   final Set<Element> closurizedMembers = new Set<Element>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
-  ResolutionUniverseImpl(this.selectorConstraintsStrategy);
+  ResolutionWorldBuilderImpl(this.selectorConstraintsStrategy);
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
   }
 
   /// All directly instantiated types, that is, the types of the directly
@@ skipping 153 matching lines @@
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
       return closure.executableContext == element;
     }));
   }
 }
 
-/// Universe specific to codegen.
+/// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
-abstract class CodegenUniverse implements Universe {
+abstract class CodegenWorldBuilder implements WorldBuilder {
   void forEachInvokedName(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   bool hasInvokedGetter(Element member, ClosedWorld world);
 
   Map<Selector, SelectorConstraints> invocationsByName(String name);
 
   Map<Selector, SelectorConstraints> getterInvocationsByName(String name);
 
   Map<Selector, SelectorConstraints> setterInvocationsByName(String name);
 
   Iterable<FunctionElement> get staticFunctionsNeedingGetter;
   Iterable<FunctionElement> get methodsNeedingSuperGetter;
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   Iterable<FieldElement> get allReferencedStaticFields;
 }
 
-class CodegenUniverseImpl implements CodegenUniverse {
+class CodegenWorldBuilderImpl implements CodegenWorldBuilder {
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
   final Set<ClassElement> _directlyInstantiatedClasses =
       new Set<ClassElement>();
 
@@ skipping 24 matching lines @@
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedGetters =
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedSetters =
       <String, Map<Selector, SelectorConstraints>>{};
 
   final Set<DartType> isChecks = new Set<DartType>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
-  CodegenUniverseImpl(this.selectorConstraintsStrategy);
+  CodegenWorldBuilderImpl(this.selectorConstraintsStrategy);
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
   }
 
   /// All directly instantiated types, that is, the types of the directly
@@ skipping 160 matching lines @@
 
   void forgetElement(Element element, Compiler compiler) {
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
       assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
       _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 }