Move processing of instantiated classes from ResolutionEnqueuer to ResolutionWorldBuilderImpl

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 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
@@ skipping 125 matching lines @@
   final CompilerTask task;
   final String name;
   final Resolution _resolution;
   final CompilerOptions _options;
   final Backend backend;
   final GlobalDependencyRegistry _globalDependencies;
   final CommonElements _commonElements;
   final native.NativeEnqueuer nativeEnqueuer;
 
   final EnqueuerStrategy strategy;
-  final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> _recentClasses = new Setlet<ClassElement>();
   final ResolutionWorldBuilderImpl _universe;
 
   bool queueIsClosed = false;
 
   WorldImpactVisitor _impactVisitor;
 
   /// All declaration elements that have been processed by the resolver.
   final Set<AstElement> processedElements = new Set<AstElement>();
 
@@ skipping 22 matching lines @@
   }
 
   ResolutionWorldBuilder get universe => _universe;
 
   OpenWorld get _openWorld => universe.openWorld;
 
   bool get queueIsEmpty => _queue.isEmpty;
 
   DiagnosticReporter get _reporter => _resolution.reporter;
 
-  Iterable<ClassElement> get processedClasses => _processedClasses;
+  Iterable<ClassElement> get processedClasses => _universe.processedClasses;
 
   void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
   void _registerInstantiatedType(InterfaceType type,
       {ConstructorElement constructor,
       bool mirrorUsage: false,
       bool nativeUsage: false,
       bool globalDependency: false,
       bool isRedirection: false}) {
     task.measure(() {
-      ClassElement cls = type.element;
-      cls.ensureResolved(_resolution);
-      bool isNative = backend.isNative(cls);
-      _universe.registerTypeInstantiation(type,
+      _universe.registerTypeInstantiation(type, _applyClassUse,
           constructor: constructor,
-          isNative: isNative,
           byMirrors: mirrorUsage,
-          isRedirection: isRedirection, onImplemented: (ClassElement cls) {
-        applyImpact(backend.registerImplementedClass(cls, forResolution: true));
-      });
+          isRedirection: isRedirection);
       if (globalDependency && !mirrorUsage) {
         _globalDependencies.registerDependency(type.element);
       }
       if (nativeUsage) {
         nativeEnqueuer.onInstantiatedType(type);
       }
       backend.registerInstantiatedType(type);
-      // TODO(johnniwinther): Share this reasoning with [Universe].
-      if (!cls.isAbstract || isNative || mirrorUsage) {
-        _processInstantiatedClass(cls);
-      }
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
   void checkClass(ClassElement cls) {
-    _processClassMembers(cls,
+    _universe.processClassMembers(cls,
         (MemberElement member, EnumSet<MemberUse> useSet) {
       if (useSet.isNotEmpty) {
         _reporter.internalError(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
   }
 
   /// Callback for applying the first seen use of a [member].
-  void _applyFirstUse(MemberElement member, EnumSet<MemberUse> useSet) {
+  void _applyFirstMemberUse(MemberElement member, EnumSet<MemberUse> useSet) {
     ClassElement cls = member.enclosingClass;
     if (member.isFunction) {
       MemberElement function = member;
       if (function.name == Identifiers.noSuchMethod_) {
         _registerNoSuchMethod(function);
       }
       if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
         _registerCallMethodWithFreeTypeVariables(function);
       }
     }
-    _applyUse(member, useSet);
+    _applyMemberUse(member, useSet);
   }
 
   /// Callback for applying the use of a [member].
-  void _applyUse(Entity member, EnumSet<MemberUse> useSet) {
+  void _applyMemberUse(Entity member, EnumSet<MemberUse> useSet) {
     if (useSet.contains(MemberUse.NORMAL)) {
       _addToWorkList(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE)) {
       _registerClosurizedMember(member);
     }
   }
 
-  /// TODO(johnniwinther): Move this to [ResolutionWorldBuilderImpl].
-  void _processInstantiatedClass(ClassElement cls) {
-    task.measure(() {
-      if (_processedClasses.contains(cls)) return;
-      // The class must be resolved to compute the set of all
-      // supertypes.
-      cls.ensureResolved(_resolution);
-
-      void processClass(ClassElement superclass) {
-        if (_processedClasses.contains(superclass)) return;
-
-        _processedClasses.add(superclass);
-        _recentClasses.add(superclass);
-        superclass.ensureResolved(_resolution);
-        _processClassMembers(superclass, _applyFirstUse);
-        _resolution.ensureClassMembers(superclass);
-        // We only tell the backend once that [superclass] was instantiated, so
-        // any additional dependencies must be treated as global
-        // dependencies.
-        applyImpact(
-            backend.registerInstantiatedClass(superclass, forResolution: true));
-      }
-
-      ClassElement superclass = cls;
-      while (superclass != null) {
-        processClass(superclass);
-        superclass = superclass.superclass;
-      }
-    });
-  }
-
-  /// TODO(johnniwinther): Move this to [ResolutionWorldBuilderImpl].
-  void _processClassMembers(ClassElement cls, MemberUsed memberUsed) {
-    cls.implementation.forEachMember((ClassElement cls, MemberElement member) {
-      _universe.processInstantiatedClassMember(cls, member, memberUsed);
-    });
+  /// Callback for applying the use of a [cls].
+  void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
+    if (useSet.contains(ClassUse.INSTANTIATED)) {
+      _recentClasses.add(cls);
+      _universe.processClassMembers(cls, _applyFirstMemberUse);
+      // We only tell the backend once that [cls] was instantiated, so
+      // any additional dependencies must be treated as global
+      // dependencies.
+      applyImpact(backend.registerInstantiatedClass(cls, forResolution: true));
+    }
+    if (useSet.contains(ClassUse.IMPLEMENTED)) {
+      applyImpact(backend.registerImplementedClass(cls, forResolution: true));
+    }
   }
 
   void processDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
-      _universe.registerDynamicUse(dynamicUse, _applyUse);
+      _universe.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     _universe.registerStaticUse(staticUse);
     applyImpact(backend.registerStaticUse(element, forResolution: true));
     bool addElement = true;
@@ skipping 232 matching lines @@
 
   void _emptyDeferredQueue() {
     while (!_deferredQueue.isEmpty) {
       _DeferredAction task = _deferredQueue.removeFirst();
       _reporter.withCurrentElement(task.element, task.action);
     }
   }
 
   void forgetElement(Element element, Compiler compiler) {
     _universe.forgetElement(element, compiler);
-    _processedClasses.remove(element);
     processedElements.remove(element);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }
 
@@ skipping 87 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }