Revert "Avoid eager enqueueing from resolution"

pkg/compiler/lib/src/resolution/resolution.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.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common/names.dart' show
     Identifiers;
 import '../common/resolution.dart' show
     Parsing,
-    Resolution,
-    ResolutionWorldImpact;
+    Resolution;
 import '../common/tasks.dart' show
     CompilerTask,
     DeferredAction;
 import '../compiler.dart' show
     Compiler;
 import '../compile_time_constants.dart' show
     ConstantCompiler;
 import '../constants/values.dart' show
     ConstantValue;
 import '../dart_types.dart';
@@ skipping 46 matching lines @@
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
   Resolution get resolution => compiler.resolution;
 
   Parsing get parsing => compiler.parsing;
 
-  ResolutionWorldImpact resolve(Element element) {
+  WorldImpact resolve(Element element) {
     return measure(() {
       if (Elements.isErroneous(element)) {
         // TODO(johnniwinther): Add a predicate for this.
         assert(invariant(element, element is! ErroneousElement,
             message: "Element $element expected to have parse errors."));
         _ensureTreeElements(element);
-        return const ResolutionWorldImpact();
+        return const WorldImpact();
       }
 
       WorldImpact processMetadata([WorldImpact result]) {
         for (MetadataAnnotation metadata in element.implementation.metadata) {
           metadata.ensureResolved(resolution);
         }
         return result;
       }
 
       ElementKind kind = element.kind;
       if (identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
           identical(kind, ElementKind.FUNCTION) ||
           identical(kind, ElementKind.GETTER) ||
           identical(kind, ElementKind.SETTER)) {
         return processMetadata(resolveMethodElement(element));
       }
 
       if (identical(kind, ElementKind.FIELD)) {
         return processMetadata(resolveField(element));
       }
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(resolution);
-        return processMetadata(const ResolutionWorldImpact());
+        return processMetadata(const WorldImpact());
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
         return processMetadata(resolveTypedef(typdef));
       }
 
       compiler.unimplemented(element, "resolve($element)");
     });
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
@@ skipping 157 matching lines @@
       }
 
       return registry.worldImpact;
     });
 
   }
 
   WorldImpact resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return reporter.withCurrentElement(element, () {
-      if (compiler.enqueuer.resolution.hasBeenProcessed(element)) {
+      if (compiler.enqueuer.resolution.hasBeenResolved(element)) {
         // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
         // should never be non-null, not even for constructors.
         assert(invariant(element, element.isConstructor,
             message: 'Non-constructor element $element '
                      'has already been analyzed.'));
-        return const ResolutionWorldImpact();
+        return const WorldImpact();
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
               new ResolutionRegistry(compiler, _ensureTreeElements(element));
           ConstructorElement constructor = element.asFunctionElement();
           ConstructorElement target = constructor.definingConstructor;
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
           // seeing this element.
           element.computeType(resolution);
           if (!target.isErroneous) {
             registry.registerStaticUse(target);
             registry.registerImplicitSuperCall(target);
           }
           return registry.worldImpact;
         } else {
           assert(element.isDeferredLoaderGetter || element.isErroneous);
           _ensureTreeElements(element);
-          return const ResolutionWorldImpact();
+          return const WorldImpact();
         }
       } else {
         element.parseNode(resolution.parsing);
         element.computeType(resolution);
         FunctionElementX implementation = element;
         if (element.isExternal) {
           implementation = compiler.backend.resolveExternalFunction(element);
         }
         return resolveMethodElementImplementation(
             implementation, implementation.node);
@@ skipping 384 matching lines @@
       if (member.isGenerativeConstructor && !member.isSynthesized) {
         reporter.reportErrorMessage(
             member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
       } else {
         // Get the resolution tree and check that the resolved member
         // doesn't use 'super'. This is the part of the 'super' mixin
         // check that happens when a function is resolved before the
         // mixin application has been performed.
         // TODO(johnniwinther): Obtain the [TreeElements] for [member]
         // differently.
-        if (compiler.enqueuer.resolution.hasBeenProcessed(member)) {
+        if (compiler.enqueuer.resolution.hasBeenResolved(member)) {
           checkMixinSuperUses(
               member.resolvedAst.elements,
               mixinApplication,
               mixin);
         }
       }
     });
   }
 
   void checkMixinSuperUses(TreeElements resolutionTree,
@@ skipping 256 matching lines @@
       FunctionExpression node = element.parseNode(parsing);
       return measure(() => SignatureResolver.analyze(
           compiler, node.parameters, node.returnType, element,
           new ResolutionRegistry(compiler, _ensureTreeElements(element)),
           defaultValuesError: defaultValuesError,
           createRealParameters: true));
     });
   }
 
   WorldImpact resolveTypedef(TypedefElementX element) {
-    if (element.isResolved) return const ResolutionWorldImpact();
+    if (element.isResolved) return const WorldImpact();
     compiler.world.allTypedefs.add(element);
     return _resolveTypeDeclaration(element, () {
       ResolutionRegistry registry = new ResolutionRegistry(
           compiler, _ensureTreeElements(element));
       return reporter.withCurrentElement(element, () {
         return measure(() {
           assert(element.resolutionState == STATE_NOT_STARTED);
           element.resolutionState = STATE_STARTED;
           Typedef node = element.parseNode(parsing);
           TypedefResolverVisitor visitor =
@@ skipping 27 matching lines @@
       node.accept(visitor);
       // TODO(johnniwinther): Avoid passing the [TreeElements] to
       // [compileMetadata].
       annotation.constant =
           constantCompiler.compileMetadata(annotation, node, registry.mapping);
       constantCompiler.evaluate(annotation.constant);
       // TODO(johnniwinther): Register the relation between the annotation
       // and the annotated element instead. This will allow the backend to
       // retrieve the backend constant and only register metadata on the
       // elements for which it is needed. (Issue 17732).
-      registry.registerMetadataConstant(annotation);
+      registry.registerMetadataConstant(annotation, annotatedElement);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   List<MetadataAnnotation> resolveMetadata(Element element,
                                            VariableDefinitions node) {
     List<MetadataAnnotation> metadata = <MetadataAnnotation>[];
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
@@ skipping 19 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }