Split Universe into ResolutionUniverse and CodegenUniverse

pkg/compiler/lib/src/enqueue.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 dart2js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
@@ skipping 113 matching lines @@
 class ResolutionEnqueuer extends Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final EnqueuerStrategy strategy;
   final Map<String, Set<Element>> instanceMembersByName =
       new Map<String, Set<Element>>();
   final Map<String, Set<Element>> instanceFunctionsByName =
       new Map<String, Set<Element>>();
   final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> recentClasses = new Setlet<ClassElement>();
-  final Universe universe = new Universe(const TypeMaskStrategy());
+  final ResolutionUniverseImpl _universe =
+      new ResolutionUniverseImpl(const TypeMaskStrategy());
 
   static final TRACE_MIRROR_ENQUEUING =
       const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
 
   bool queueIsClosed = false;
 
   bool hasEnqueuedReflectiveElements = false;
   bool hasEnqueuedReflectiveStaticFields = false;
 
   WorldImpactVisitor impactVisitor;
 
   ResolutionEnqueuer(Compiler compiler, this.strategy)
       : this.name = 'resolution enqueuer',
         this.compiler = compiler,
         processedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
         deferredQueue = new Queue<_DeferredAction>() {
     impactVisitor = new _EnqueuerImpactVisitor(this);
   }
 
   // TODO(johnniwinther): Move this to [ResolutionEnqueuer].
   Resolution get resolution => compiler.resolution;
 
+  ResolutionUniverse get universe => _universe;
+
   bool get queueIsEmpty => queue.isEmpty;
 
   QueueFilter get filter => compiler.enqueuerFilter;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   bool isClassProcessed(ClassElement cls) => _processedClasses.contains(cls);
 
   Iterable<ClassElement> get processedClasses => _processedClasses;
 
@@ skipping 16 matching lines @@
   void applyImpact(Element element, WorldImpact worldImpact) {
     compiler.impactStrategy
         .visitImpact(element, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
       bool isNative = compiler.backend.isNative(cls);
-      universe.registerTypeInstantiation(type,
+      _universe.registerTypeInstantiation(type,
           isNative: isNative,
           byMirrors: mirrorUsage, onImplemented: (ClassElement cls) {
         compiler.backend
             .registerImplementedClass(cls, this, compiler.globalDependencies);
       });
       // TODO(johnniwinther): Share this reasoning with [Universe].
       if (!cls.isAbstract || isNative || mirrorUsage) {
         processInstantiatedClass(cls);
       }
     });
@@ skipping 16 matching lines @@
     if (member.isField) {
       // The obvious thing to test here would be "member.isNative",
       // however, that only works after metadata has been parsed/analyzed,
       // and that may not have happened yet.
       // So instead we use the enclosing class, which we know have had
       // its metadata parsed and analyzed.
       // Note: this assumes that there are no non-native fields on native
       // classes, which may not be the case when a native class is subclassed.
       if (compiler.backend.isNative(cls)) {
         compiler.openWorld.registerUsedElement(member);
-        if (universe.hasInvokedGetter(member, compiler.openWorld) ||
-            universe.hasInvocation(member, compiler.openWorld)) {
+        if (_universe.hasInvokedGetter(member, compiler.openWorld) ||
+            _universe.hasInvocation(member, compiler.openWorld)) {
           addToWorkList(member);
           return;
         }
-        if (universe.hasInvokedSetter(member, compiler.openWorld)) {
+        if (_universe.hasInvokedSetter(member, compiler.openWorld)) {
           addToWorkList(member);
           return;
         }
         // Native fields need to go into instanceMembersByName as they
         // are virtual instantiation points and escape points.
       } else {
         // All field initializers must be resolved as they could
         // have an observable side-effect (and cannot be tree-shaken
         // away).
         addToWorkList(member);
         return;
       }
     } else if (member.isFunction) {
       FunctionElement function = member;
       function.computeType(resolution);
       if (function.name == Identifiers.noSuchMethod_) {
         registerNoSuchMethod(function);
       }
       if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
         registerCallMethodWithFreeTypeVariables(function);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
-      if (universe.hasInvokedGetter(function, compiler.openWorld)) {
+      if (_universe.hasInvokedGetter(function, compiler.openWorld)) {
         registerClosurizedMember(function);
         addToWorkList(function);
         return;
       }
       // Store the member in [instanceFunctionsByName] to catch
       // getters on the function.
       instanceFunctionsByName
           .putIfAbsent(memberName, () => new Set<Element>())
           .add(member);
-      if (universe.hasInvocation(function, compiler.openWorld)) {
+      if (_universe.hasInvocation(function, compiler.openWorld)) {
         addToWorkList(function);
         return;
       }
     } else if (member.isGetter) {
       FunctionElement getter = member;
       getter.computeType(resolution);
-      if (universe.hasInvokedGetter(getter, compiler.openWorld)) {
+      if (_universe.hasInvokedGetter(getter, compiler.openWorld)) {
         addToWorkList(getter);
         return;
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
-      if (universe.hasInvocation(getter, compiler.openWorld)) {
+      if (_universe.hasInvocation(getter, compiler.openWorld)) {
         addToWorkList(getter);
         return;
       }
     } else if (member.isSetter) {
       FunctionElement setter = member;
       setter.computeType(resolution);
-      if (universe.hasInvokedSetter(setter, compiler.openWorld)) {
+      if (_universe.hasInvokedSetter(setter, compiler.openWorld)) {
         addToWorkList(setter);
         return;
       }
     }
 
     // The element is not yet used. Add it to the list of instance
     // members to still be processed.
     instanceMembersByName
         .putIfAbsent(memberName, () => new Set<Element>())
         .add(member);
@@ skipping 26 matching lines @@
       ClassElement superclass = cls;
       while (superclass != null) {
         processClass(superclass);
         superclass = superclass.superclass;
       }
     });
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
-      if (universe.registerDynamicUse(dynamicUse)) {
+      if (_universe.registerDynamicUse(dynamicUse)) {
         handleUnseenSelector(dynamicUse);
       }
     });
   }
 
   void logEnqueueReflectiveAction(action, [msg = ""]) {
     if (TRACE_MIRROR_ENQUEUING) {
       print("MIRROR_ENQUEUE (R): $action $msg");
     }
   }
@@ skipping 215 matching lines @@
    * Invariant: [element] must be a declaration element.
    */
   void registerStaticUse(StaticUse staticUse) {
     strategy.processStaticUse(this, staticUse);
   }
 
   void registerStaticUseInternal(StaticUse staticUse) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
-    universe.registerStaticUse(staticUse);
+    _universe.registerStaticUse(staticUse);
     compiler.backend.registerStaticUse(element, this);
     bool addElement = true;
     switch (staticUse.kind) {
       case StaticUseKind.STATIC_TEAR_OFF:
         compiler.backend.registerGetOfStaticFunction(this);
         break;
       case StaticUseKind.FIELD_GET:
       case StaticUseKind.FIELD_SET:
       case StaticUseKind.CLOSURE:
         // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
@@ skipping 28 matching lines @@
         if (compiler.options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
-    type = universe.registerIsCheck(type, compiler);
+    type = _universe.registerIsCheck(type, compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
   }
 
   void registerCallMethodWithFreeTypeVariables(Element element) {
     compiler.backend.registerCallMethodWithFreeTypeVariables(
         element, this, compiler.globalDependencies);
-    universe.callMethodsWithFreeTypeVariables.add(element);
+    _universe.callMethodsWithFreeTypeVariables.add(element);
   }
 
   void registerClosurizedMember(TypedElement element) {
     assert(element.isInstanceMember);
     if (element.computeType(resolution).containsTypeVariables) {
       compiler.backend.registerClosureWithFreeTypeVariables(
           element, this, compiler.globalDependencies);
+      _universe.closuresWithFreeTypeVariables.add(element);
     }
     compiler.backend.registerBoundClosure(this);
-    universe.closurizedMembers.add(element);
+    _universe.closurizedMembers.add(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         filter.processWorkItem(f, queue.removeLast());
       }
       List recents = recentClasses.toList(growable: false);
       recentClasses.clear();
@@ skipping 149 matching lines @@
   void emptyDeferredQueueForTesting() => _emptyDeferredQueue();
 
   void _emptyDeferredQueue() {
     while (!deferredQueue.isEmpty) {
       _DeferredAction task = deferredQueue.removeFirst();
       reporter.withCurrentElement(task.element, task.action);
     }
   }
 
   void forgetElement(Element element) {
-    universe.forgetElement(element, compiler);
+    _universe.forgetElement(element, compiler);
     _processedClasses.remove(element);
     instanceMembersByName[element.name]?.remove(element);
     instanceFunctionsByName[element.name]?.remove(element);
     processedElements.remove(element);
   }
 }
 
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
@@ skipping 78 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }