Introduce WorldImpact

pkg/compiler/lib/src/compiler.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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 14 matching lines @@
    * Invariant: [element] must be a declaration element.
    */
   final AstElement element;
 
   TreeElements get resolutionTree;
 
   WorkItem(this.element, this.compilationContext) {
     assert(invariant(element, element.isDeclaration));
   }
 
-  void run(Compiler compiler, Enqueuer world);
+  WorldImpact run(Compiler compiler, Enqueuer world);
 }
 
 /// [WorkItem] used exclusively by the [ResolutionEnqueuer].
 class ResolutionWorkItem extends WorkItem {
   TreeElements resolutionTree;
 
   ResolutionWorkItem(AstElement element,
                      ItemCompilationContext compilationContext)
       : super(element, compilationContext);
 
-  void run(Compiler compiler, ResolutionEnqueuer world) {
-    compiler.analyze(this, world);
+  WorldImpact run(Compiler compiler, ResolutionEnqueuer world) {
+    WorldImpact impact = compiler.analyze(this, world);
     resolutionTree = element.resolvedAst.elements;
+    return impact;
   }
 
   bool isAnalyzed() => resolutionTree != null;
 }
 
 // TODO(johnniwinther): Split this class into interface and implementation.
 // TODO(johnniwinther): Move this implementation to the JS backend.
 class CodegenRegistry extends Registry {
   final Compiler compiler;
   final TreeElements treeElements;
@@ skipping 15 matching lines @@
     treeElements.registerDependency(element);
   }
 
   void registerInlining(Element inlinedElement, Element context) {
     if (compiler.dumpInfo) {
       compiler.dumpInfoTask.registerInlined(inlinedElement, context);
     }
   }
 
   void registerInstantiatedClass(ClassElement element) {
-    world.registerInstantiatedClass(element, this);
+    world.registerInstantiatedType(element.rawType, this);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     world.registerInstantiatedType(type, this);
   }
 
   void registerStaticUse(Element element) {
     world.registerStaticUse(element);
   }
 
@@ skipping 18 matching lines @@
 
   void registerFieldGetter(Element element) {
     world.registerFieldGetter(element);
   }
 
   void registerFieldSetter(Element element) {
     world.registerFieldSetter(element);
   }
 
   void registerIsCheck(DartType type) {
-    world.registerIsCheck(type, this);
+    world.registerIsCheck(type);
     backend.registerIsCheckForCodegen(type, world, this);
   }
 
   void registerCompileTimeConstant(ConstantValue constant) {
     backend.registerCompileTimeConstant(constant, this);
     backend.constants.addCompileTimeConstantForEmission(constant);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(DartType subtype,
                                               DartType supertype) {
@@ skipping 45 matching lines @@
   }
 
   void registerAsyncMarker(FunctionElement element) {
     backend.registerAsyncMarker(element, world, this);
   }
 
 }
 
 /// [WorkItem] used exclusively by the [CodegenEnqueuer].
 class CodegenWorkItem extends WorkItem {
-  Registry registry;
+  CodegenRegistry registry;
 
   factory CodegenWorkItem(
       Compiler compiler,
       AstElement element,
       ItemCompilationContext compilationContext) {
     // If this assertion fails, the resolution callbacks of the backend may be
     // missing call of form registry.registerXXX. Alternatively, the code
     // generation could spuriously be adding dependencies on things we know we
     // don't need.
     assert(invariant(element,
         compiler.enqueuer.resolution.hasBeenResolved(element),
         message: "$element has not been resolved."));
     assert(invariant(element, element.resolvedAst.elements != null,
         message: 'Resolution tree is null for $element in codegen work item'));
     return new CodegenWorkItem.internal(element, compilationContext);
   }
 
   CodegenWorkItem.internal(
       AstElement element,
       ItemCompilationContext compilationContext)
       : super(element, compilationContext);
 
   TreeElements get resolutionTree => element.resolvedAst.elements;
 
-  void run(Compiler compiler, CodegenEnqueuer world) {
-    if (world.isProcessed(element)) return;
+  WorldImpact run(Compiler compiler, CodegenEnqueuer world) {
+    if (world.isProcessed(element)) return const WorldImpact();
 
     registry = new CodegenRegistry(compiler, resolutionTree);
-    compiler.codegen(this, world);
+    return compiler.codegen(this, world);
   }
 }
 
 typedef void DeferredAction();
 
 class DeferredTask {
   final Element element;
   final DeferredAction action;
 
   DeferredTask(this.element, this.action);
@@ skipping 13 matching lines @@
 
   void registerDynamicGetter(Selector selector);
 
   void registerDynamicSetter(Selector selector);
 
   void registerStaticInvocation(Element element);
 
   void registerInstantiation(InterfaceType type);
 
   void registerGetOfStaticFunction(FunctionElement element);
-
-  void registerAsyncMarker(FunctionElement element);
 }
 
 abstract class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem;
@@ skipping 16 matching lines @@
   /// otherwise visible during resolution.
   Iterable<ClassElement> classesRequiredForReflection = const [];
 
   // Given a [FunctionElement], return a buffer with the code generated for it
   // or null if no code was generated.
   CodeBuffer codeOf(Element element) => null;
 
   void initializeHelperClasses() {}
 
   void enqueueHelpers(ResolutionEnqueuer world, Registry registry);
-  void codegen(CodegenWorkItem work);
+  WorldImpact codegen(CodegenWorkItem work);
 
   // The backend determines the native resolution enqueuer, with a no-op
   // default, so tools like dart2dart can ignore the native classes.
   native.NativeEnqueuer nativeResolutionEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
   native.NativeEnqueuer nativeCodegenEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
 
@@ skipping 1390 matching lines @@
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(this);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
-      world.registerInstantiatedClass(element, globalDependencies);
+      world.registerInstantiatedType(cls.rawType, globalDependencies);
     } else {
       world.addToWorkList(element);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(this);
         }
       }
     }
   }
 
   void processQueue(Enqueuer world, Element main) {
     world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
     if (main != null && !main.isErroneous) {
       FunctionElement mainMethod = main;
       if (mainMethod.computeSignature(this).parameterCount != 0) {
         // The first argument could be a list of strings.
-        world.registerInstantiatedClass(
-            backend.listImplementation, globalDependencies);
-        world.registerInstantiatedClass(
-            backend.stringImplementation, globalDependencies);
+        backend.listImplementation.ensureResolved(this);
+        world.registerInstantiatedType(
+            backend.listImplementation.rawType, globalDependencies);
+        backend.stringImplementation.ensureResolved(this);
+        world.registerInstantiatedType(
+            backend.stringImplementation.rawType, globalDependencies);
 
         backend.registerMainHasArguments(world);
       }
       world.addToWorkList(main);
     }
     if (verbose) {
       progress.reset();
     }
     world.forEach((WorkItem work) {
-      withCurrentElement(work.element, () => work.run(this, world));
+      withCurrentElement(work.element, () {
+        world.applyImpact(work.element, work.run(this, world));
+      });
     });
     world.queueIsClosed = true;
     assert(compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
   }
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
@@ skipping 25 matching lines @@
       }
     }
     log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reportWarning(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  void analyzeElement(Element element) {
+  WorldImpact analyzeElement(Element element) {
     assert(invariant(element,
            element.impliesType ||
            element.isField ||
            element.isFunction ||
            element.isGenerativeConstructor ||
            element.isGetter ||
            element.isSetter,
            message: 'Unexpected element kind: ${element.kind}'));
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     assert(invariant(element, element.isDeclaration));
     ResolutionEnqueuer world = enqueuer.resolution;
-    if (world.hasBeenResolved(element)) return;
+    if (world.hasBeenResolved(element)) {
+      return const WorldImpact();
+    }
     assert(parser != null);
     Node tree = parser.parse(element);
     assert(invariant(element, !element.isSynthesized || tree == null));
-    TreeElements elements = resolver.resolve(element);
-    if (elements != null) {
-      if (tree != null && !analyzeSignaturesOnly &&
-          !suppressWarnings) {
-        // Only analyze nodes with a corresponding [TreeElements].
-        checker.check(elements);
-      }
-      world.registerResolvedElement(element);
+    WorldImpact worldImpact = resolver.resolve(element);
+    if (tree != null && !analyzeSignaturesOnly &&
+        !suppressWarnings) {
+      // Only analyze nodes with a corresponding [TreeElements].
+      checker.check(element);
     }
+    world.registerResolvedElement(element);
+    return worldImpact;
   }
 
-  void analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
+  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.resolution)));
     assert(invariant(work.element, !work.isAnalyzed(),
         message: 'Element ${work.element} has already been analyzed'));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
         log('Resolved ${enqueuer.resolution.resolvedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
-    if (world.hasBeenResolved(element)) return;
-    analyzeElement(element);
+    if (world.hasBeenResolved(element)) {
+      return const WorldImpact();
+    }
+    WorldImpact worldImpact = analyzeElement(element);
     backend.onElementResolved(element, element.resolvedAst.elements);
+    return worldImpact;
   }
 
-  void codegen(CodegenWorkItem work, CodegenEnqueuer world) {
+  WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       log('Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
     }
-    backend.codegen(work);
+    return backend.codegen(work);
   }
 
   void reportError(Spannable node,
                    MessageKind messageKind,
                    [Map arguments = const {}]) {
     reportDiagnosticInternal(
         node, messageKind, arguments, api.Diagnostic.ERROR);
   }
 
   void reportWarning(Spannable node, MessageKind messageKind,
@@ skipping 608 matching lines @@
     return futureClass.computeType(compiler).createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType = const DynamicType()]) {
     return streamClass.computeType(compiler).createInstantiation([elementType]);
   }
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);