Introduce WorldImpact

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.
 
 part of dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 14 matching lines @@
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 
   void forgetElement(Element element) {
     resolution.forgetElement(element);
     codegen.forgetElement(element);
   }
 }
 
+class WorldImpact {
+  const WorldImpact();
+
+  Iterable<Selector> get dynamicInvocations => const <Selector>[];
+  Iterable<Selector> get dynamicGetters => const <Selector>[];
+  Iterable<Selector> get dynamicSetters => const <Selector>[];
+
+  // TODO(johnniwinther): Split this into more precise subsets.
+  Iterable<Element> get staticUses => const <Element>[];
+
+  // TODO(johnniwinther): Replace this by called constructors with type
+  // arguments.
+  Iterable<InterfaceType> get instantiatedTypes => const <InterfaceType>[];
+
+  // TODO(johnniwinther): Collect checked types for checked mode separately to
+  // support serialization.
+  Iterable<DartType> get checkedTypes => const <DartType>[];
+
+  Iterable<MethodElement> get closurizedFunctions => const <MethodElement>[];
+}
+
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final ItemCompilationContextCreator itemCompilationContextCreator;
   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>();
@@ skipping 32 matching lines @@
     internalAddToWorkList(element);
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
    *
    * Returns [true] if the element was actually added to the queue.
    */
   bool internalAddToWorkList(Element element);
 
+  /// Apply the [worldImpact] of processing [element] to this enqueuer.
+  void applyImpact(Element element, WorldImpact worldImpact) {
+    // TODO(johnniwinther): Optimize the application of the world impact.
+    worldImpact.dynamicInvocations.forEach(registerDynamicInvocation);
+    worldImpact.dynamicGetters.forEach(registerDynamicGetter);
+    worldImpact.dynamicSetters.forEach(registerDynamicSetter);
+    worldImpact.staticUses.forEach(registerStaticUse);
+    // TODO(johnniwinther): Register [worldImpact.instantiatedTypes] when it
+    // doesn't require a [Registry].
+    worldImpact.checkedTypes.forEach(registerIsCheck);
+    worldImpact.closurizedFunctions.forEach(registerGetOfStaticFunction);
+  }
+
+  // TODO(johnniwinther): Remove the need for passing the [registry].
   void registerInstantiatedType(InterfaceType type, Registry registry,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       registry.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.registerTypeInstantiation(type, byMirrors: mirrorUsage);
       processInstantiatedClass(cls);
       compiler.backend.registerInstantiatedType(type, registry);
     });
   }
 
-  void registerInstantiatedClass(ClassElement cls, Registry registry,
-                                 {bool mirrorUsage: false}) {
-    cls.ensureResolved(compiler);
-    registerInstantiatedType(cls.rawType, registry, mirrorUsage: mirrorUsage);
-  }
-
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
 
   void processInstantiatedClassMembers(ClassElement cls) {
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
@@ skipping 228 matching lines @@
   /// needed for reflection.
   void enqueueReflectiveElementsInClass(ClassElement cls,
                                         Iterable<ClassElement> recents,
                                         bool enclosingWasIncluded) {
     if (cls.library.isInternalLibrary || cls.isInjected) return;
     bool includeClass = shouldIncludeElementDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
       logEnqueueReflectiveAction(cls, "register");
       ClassElement decl = cls.declaration;
-      registerInstantiatedClass(decl, compiler.mirrorDependencies,
+      decl.ensureResolved(compiler);
+      registerInstantiatedType(decl.rawType, compiler.mirrorDependencies,
           mirrorUsage: true);
     }
     // If the class is never instantiated, we know nothing of it can possibly
     // be reflected upon.
     // TODO(herhut): Add a warning if a mirrors annotation cannot hit.
     if (recents.contains(cls.declaration)) {
       logEnqueueReflectiveAction(cls, "members");
       cls.constructors.forEach((Element element) {
         enqueueReflectiveConstructor(element, includeClass);
       });
       cls.forEachClassMember((Member member) {
         enqueueReflectiveMember(member.element, includeClass);
       });
     }
   }
 
   /// Enqeue special classes that might not be visible by normal means or that
   /// would not normally be enqueued:
   ///
   /// [Closure] is treated specially as it is the superclass of all closures.
   /// Although it is in an internal library, we mark it as reflectable. Note
   /// that none of its methods are reflectable, unless reflectable by
   /// inheritance.
   void enqueueReflectiveSpecialClasses() {
     Iterable<ClassElement> classes =
         compiler.backend.classesRequiredForReflection;
     for (ClassElement cls in classes) {
       if (compiler.backend.referencedFromMirrorSystem(cls)) {
         logEnqueueReflectiveAction(cls);
-        registerInstantiatedClass(cls, compiler.mirrorDependencies,
+        cls.ensureResolved(compiler);
+        registerInstantiatedType(cls.rawType, compiler.mirrorDependencies,
             mirrorUsage: true);
       }
     }
   }
 
   /// Enqeue all local members of the library [lib] if they are required for
   /// reflection.
   void enqueueReflectiveElementsInLibrary(LibraryElement lib,
                                           Iterable<ClassElement> recents) {
     bool includeLibrary = shouldIncludeElementDueToMirrors(lib,
@@ skipping 163 matching lines @@
   }
 
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
 
   void registerFieldSetter(Element element) {
     universe.fieldSetters.add(element);
   }
 
-  void registerIsCheck(DartType type, Registry registry) {
+  void registerIsCheck(DartType type) {
     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.kind != TypeKind.TYPE_VARIABLE ||
            !type.element.enclosingElement.isTypedef);
   }
 
   void registerCallMethodWithFreeTypeVariables(
       Element element,
@@ skipping 334 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }