Handle metadata on nested function parameters.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 241 matching lines @@
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       if (Elements.isErroneousElement(element)) return null;
 
-      for (MetadataAnnotation metadata in element.metadata) {
-        metadata.ensureResolved(compiler);
+      processMetadata([result]) {
+        for (MetadataAnnotation metadata in element.metadata) {
+          metadata.ensureResolved(compiler);
+        }
+        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 resolveMethodElement(element);
+        return processMetadata(resolveMethodElement(element));
       }
 
-      if (identical(kind, ElementKind.FIELD)) return resolveField(element);
-
+      if (identical(kind, ElementKind.FIELD)) {
+        return processMetadata(resolveField(element));
+      }
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
-        return null;
+        return processMetadata();
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
-        return resolveTypedef(typdef);
+        return processMetadata(resolveTypedef(typdef));
       }
 
       compiler.unimplemented(element, "resolve($element)");
     });
   }
 
   String constructorNameForDiagnostics(String className,
                                        String constructorName) {
     String classNameString = className;
     String constructorNameString = constructorName;
@@ skipping 246 matching lines @@
             for (MixinApplicationElement mixinApplication in mixinUses) {
               checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
             }
           }
         }
         return resolutionTree;
       });
     });
   }
 
+  /// Creates a [ResolverVisitor] for resolving an AST in context of [element].
+  /// If [useEnclosingScope] is `true` then the initial scope of the visitor
+  /// does not include inner scope of [element].
+  ///
   /// This method should only be used by this library (or tests of
   /// this library).
-  ResolverVisitor visitorFor(Element element) {
+  ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
     return new ResolverVisitor(compiler, element,
-        new ResolutionRegistry(compiler, element));
+        new ResolutionRegistry(compiler, element),
+        useEnclosingScope: useEnclosingScope);
   }
 
   TreeElements resolveField(VariableElementX element) {
     VariableDefinitions tree = element.parseNode(compiler);
     if(element.modifiers.isStatic && element.isTopLevel) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     ResolutionRegistry registry = visitor.registry;
@@ skipping 604 matching lines @@
           defaultValuesError: defaultValuesError));
     });
   }
 
   TreeElements resolveTypedef(TypedefElementX element) {
     if (element.isResolved) return element.treeElements;
     return _resolveTypeDeclaration(element, () {
       ResolutionRegistry registry = new ResolutionRegistry(compiler, element);
       return compiler.withCurrentElement(element, () {
         return measure(() {
+          assert(element.resolutionState == STATE_NOT_STARTED);
+          element.resolutionState = STATE_STARTED;
           Typedef node =
             compiler.parser.measure(() => element.parseNode(compiler));
           TypedefResolverVisitor visitor =
             new TypedefResolverVisitor(compiler, element, registry);
           visitor.visit(node);
-
+          element.resolutionState = STATE_DONE;
           return registry.mapping;
         });
       });
     });
   }
 
   void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
     compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
       assert(annotation.resolutionState == STATE_NOT_STARTED);
       annotation.resolutionState = STATE_STARTED;
 
       Node node = annotation.parseNode(compiler);
-      // TODO(johnniwinther): Find the right analyzable element to hold the
-      // [TreeElements] for the annotation.
       Element annotatedElement = annotation.annotatedElement;
-      Element context = annotatedElement.enclosingElement;
-      if (context == null) {
-        context = annotatedElement;
-      }
-      ResolverVisitor visitor = visitorFor(context);
+      AnalyzableElement context = annotatedElement.analyzableElement;
+      assert(invariant(node, context != null,
+          message: "No context found for metadata annotation "
+                   "on $annotatedElement."));
+      ResolverVisitor visitor = visitorFor(context, useEnclosingScope: true);
       ResolutionRegistry registry = visitor.registry;
       node.accept(visitor);
       // TODO(johnniwinther): Avoid passing the [TreeElements] to
       // [compileMetadata].
       annotation.value =
           constantCompiler.compileMetadata(annotation, node, registry.mapping);
       // TODO(johnniwinther): Register the relation between the annotation
-      // and the annotated element instead. This will allow the backed to
-      // retrieve the backend constant and only registered metadata on the
+      // 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.value);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Spannable node, MessageKind kind, [arguments = const {}]) {
     // TODO(ahe): Make non-fatal.
     compiler.reportFatalError(node, kind, arguments);
   }
@@ skipping 555 matching lines @@
         } else {
           if (arguments.isEmpty) {
             type = cls.rawType;
           } else {
             type = new InterfaceType(cls.declaration, arguments.toLink());
             addTypeVariableBoundsCheck = true;
           }
         }
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
-        // TODO(ahe): Should be [ensureResolved].
-        compiler.resolveTypedef(typdef);
+        typdef.ensureResolved(compiler);

[karlklose, 2014/05/27 07:52:46]

Add a TODO that resolution should imply that the type is resolved (also for
classes).

[Johnni Winther, 2014/05/27 08:43:32]

Done.

+        element.computeType(compiler);
         var arguments = new LinkBuilder<DartType>();
         bool hasTypeArgumentMismatch = resolveTypeArguments(
             visitor, node, typdef.typeVariables, arguments);
         if (hasTypeArgumentMismatch) {
           type = new BadTypedefType(typdef,
               new TypedefType.forUserProvidedBadType(typdef,
                                                      arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
@@ skipping 195 matching lines @@
                  r'>|'
                  r'<=|'
                  r'<|'
                  r'&|'
                  r'\^|'
                  r'\|'
                  r')$');
 
   ResolverVisitor(Compiler compiler,
                   Element element,
-                  ResolutionRegistry registry)
+                  ResolutionRegistry registry,
+                  {bool useEnclosingScope: false})
     : this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember && !element.isField)
           || element.isGenerativeConstructor,
       this.currentClass = element.isMember ? element.enclosingClass
                                              : null,
       this.statementScope = new StatementScope(),
-      scope = element.buildScope(),
+      scope = useEnclosingScope
+          ? Scope.buildEnclosingScope(element) : element.buildScope(),
       // The type annotations on a typedef do not imply type checks.
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
           !element.isLibrary &&
           !element.isTypedef &&
           !element.enclosingElement.isTypedef,
       inCatchBlock = false,
       super(compiler, registry);
 
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
@@ skipping 1892 matching lines @@
  * This visitor has to be extra careful as it is building the basic
  * element information, and cannot safely look at other elements as
  * this may lead to cycles.
  *
  * This visitor can assume that the supertypes have already been
  * resolved, but it cannot call [ResolverTask.resolveClass] directly
  * or indirectly (through [ClassElement.ensureResolved]) for any other
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
-  ClassElement get element => enclosingElement;
+  BaseClassElementX get element => enclosingElement;
 
   ClassResolverVisitor(Compiler compiler,
                        ClassElement classElement,
                        ResolutionRegistry registry)
     : super(compiler, classElement, registry);
 
   DartType visitClassNode(ClassNode node) {
     invariant(node, element != null);
     invariant(element, element.resolutionState == STATE_STARTED,
         message: () => 'cyclic resolution of class $element');
@@ skipping 710 matching lines @@
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }
 
-TreeElements _ensureTreeElements(AnalyzableElement element) {
+TreeElements _ensureTreeElements(AnalyzableElementX element) {
   if (element._treeElements == null) {
     element._treeElements = new TreeElementMapping(element);
   }
   return element._treeElements;
 }
 
-abstract class AnalyzableElement implements Element {
+abstract class AnalyzableElementX implements AnalyzableElement {
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 }