Support parameter metadata.

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 1178 matching lines @@
       optionalParameterTypes = optionalParameterTypesBuilder.toLink();
     }
     return new FunctionType(element,
         signature.returnType,
         parameterTypes.toLink(),
         optionalParameterTypes,
         namedParameters,
         namedParameterTypes);
   }
 
-  void resolveMetadataAnnotation(PartialMetadataAnnotation annotation) {
+  void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
     compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
       assert(annotation.resolutionState == STATE_NOT_STARTED);
       annotation.resolutionState = STATE_STARTED;
 
       Node node = annotation.parseNode(compiler);
       Element annotatedElement = annotation.annotatedElement;
       Element context = annotatedElement.enclosingElement;
       if (context == null) {
         context = annotatedElement;
       }
@@ skipping 1742 matching lines @@
 
   visitThrow(Throw node) {
     compiler.backend.registerThrowExpression(mapping);
     visit(node.expression);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this,
                                        ElementKind.VARIABLE);
+    VariableListElement variables = visitor.variables;
     // Ensure that we set the type of the [VariableListElement] since it depends
     // on the current scope. If the current scope is a [MethodScope] or
     // [BlockScope] it will not be available for the
     // [VariableListElement.computeType] method.
     if (node.type != null) {
-      visitor.variables.type = resolveTypeAnnotation(node.type);
+      variables.type = resolveTypeAnnotation(node.type);
     } else {
-      visitor.variables.type = compiler.types.dynamicType;
+      variables.type = compiler.types.dynamicType;
     }
 
     Modifiers modifiers = node.modifiers;
     void reportExtraModifier(String modifier) {
       Node modifierNode;
       for (Link<Node> nodes = modifiers.nodes.nodes;
            !nodes.isEmpty;
            nodes = nodes.tail) {
         if (modifier == nodes.head.asIdentifier().source) {
           modifierNode = nodes.head;
@@ skipping 11 matching lines @@
       reportExtraModifier('var');
     }
     if (enclosingElement.isFunction()) {
       if (modifiers.isAbstract()) {
         reportExtraModifier('abstract');
       }
       if (modifiers.isStatic()) {
         reportExtraModifier('static');
       }
     }
+    if (node.metadata != null) {
+      // TODO(johnniwinther): Unify handling of metadata on locals/formals.
+      for (Link<Node> link = node.metadata.nodes;
+           !link.isEmpty;
+           link = link.tail) {
+        ParameterMetadataAnnotation metadata =
+            new ParameterMetadataAnnotation(link.head);
+        variables.addMetadata(metadata);
+        addDeferredAction(variables, () {

[floitsch, 2014/02/06 23:09:46]

why do we need to defer the action?

+          metadata.ensureResolved(compiler);
+        });
+      }
+    }
     visitor.visit(node.definitions);
   }
 
   visitWhile(While node) {
     visit(node.condition);
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
@@ skipping 1494 matching lines @@
     return finishConstructorReference(visit(expression),
                                       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);
 }