Use WorldImpact for element dependencies in deferred_load

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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
@@ skipping 10 matching lines @@
     CodegenWorkItem;
 import 'common/names.dart' show
     Identifiers,
     Uris;
 import 'common/registry.dart' show
     Registry;
 import 'common/resolution.dart' show
     Parsing,
     Resolution,
     ResolutionWorkItem,
-    ResolutionWorldImpact;
+    ResolutionImpact;
 import 'common/tasks.dart' show
     CompilerTask,
     GenericTask;
 import 'common/work.dart' show
     WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show
     CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
@@ skipping 1121 matching lines @@
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  ResolutionWorldImpact 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));
-    return resolution.analyzeElement(element);
+    return resolution.computeWorldImpact(element);
   }
 
-  ResolutionWorldImpact 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) {
         reporter.log(
             'Resolved ${enqueuer.resolution.processedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
     if (world.hasBeenProcessed(element)) {
-      return const ResolutionWorldImpact();
+      return const WorldImpact();
     }
-    ResolutionWorldImpact worldImpact = analyzeElement(element);
+    WorldImpact worldImpact = analyzeElement(element);
     backend.onElementResolved(element, element.resolvedAst.elements);
     world.registerProcessedElement(element);
     return worldImpact;
   }
 
   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.
@@ skipping 705 matching lines @@
             const <DiagnosticMessage>[],
             api.Diagnostic.HINT);
       });
     }
   }
 }
 
 // TODO(johnniwinther): Move [ResolverTask] here.
 class _CompilerResolution implements Resolution {
   final Compiler compiler;
-  final Map<Element, ResolutionWorldImpact> _worldImpactCache =
-      <Element, ResolutionWorldImpact>{};
+  final Map<Element, WorldImpact> _worldImpactCache = <Element, WorldImpact>{};
 
   _CompilerResolution(this.compiler);
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
   Parsing get parsing => compiler.parsing;
 
   @override
@@ skipping 22 matching lines @@
   @override
   FunctionSignature resolveSignature(FunctionElement function) {
     return compiler.resolver.resolveSignature(function);
   }
 
   @override
   DartType resolveTypeAnnotation(Element element, TypeAnnotation node) {
     return compiler.resolver.resolveTypeAnnotation(element, node);
   }
 
-  ResolutionWorldImpact analyzeElement(Element element) {
+  @override
+  WorldImpact getWorldImpact(Element element) {
+    WorldImpact worldImpact = _worldImpactCache[element];
+    assert(invariant(element, worldImpact != null,
+        message: "WorldImpact not computed for $element."));
+    return worldImpact;
+  }
+
+  @override
+  WorldImpact computeWorldImpact(Element element) {
     return _worldImpactCache.putIfAbsent(element, () {
       assert(compiler.parser != null);
       Node tree = compiler.parser.parse(element);
       assert(invariant(element, !element.isSynthesized || tree == null));
-      ResolutionWorldImpact worldImpact = compiler.resolver.resolve(element);
+      ResolutionImpact resolutionImpact =
+          compiler.resolver.resolve(element);
       if (tree != null &&
           !compiler.analyzeSignaturesOnly &&
           !reporter.options.suppressWarnings) {
         // Only analyze nodes with a corresponding [TreeElements].
         compiler.checker.check(element);
       }
+      WorldImpact worldImpact =
+          compiler.backend.resolutionCallbacks.transformImpact(
+              resolutionImpact);
       return worldImpact;
     });
   }
 
   @override
   bool hasBeenResolved(Element element) {
     return _worldImpactCache.containsKey(element);
   }
 }
 
@@ skipping 12 matching lines @@
 
   @override
   void parsePatchClass(ClassElement cls) {
     compiler.patchParser.measure(() {
       if (cls.isPatch) {
         compiler.patchParser.parsePatchClassNode(cls);
       }
     });
   }
 }