Implement metadata on methods and fields.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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 fasta.body_builder;
 
 import '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 321 matching lines @@
           fileUri: error.uri);
     }
   }
 
   @override
   JumpTarget createJumpTarget(JumpTargetKind kind, int charOffset) {
     return new JumpTarget(kind, functionNestingLevel, member, charOffset);
   }
 
   @override
+  void beginMetadata(Token token) {
+    debugEvent("beginMetadata");
+    super.push(constantExpressionRequired);
+    constantExpressionRequired = true;
+  }
+
+  @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
-    pop(); // Arguments.
-    popIfNotNull(periodBeforeName); // Postfix.
-    pop(); // Type arguments.
-    pop(); // Expression or type name (depends on arguments).
-    // TODO(ahe): Implement metadata on local declarations.
+    var arguments = pop();
+    if (arguments != null) {
+      endConstructorReference(beginToken, periodBeforeName, endToken);
+      push(arguments);
+      endNewExpression(beginToken);
+      push(popForValue());
+    } else {
+      var postfix = popIfNotNull(periodBeforeName);
+      if (postfix != null) {
+        addCompileTimeError(offsetForToken(beginToken), "Not implemented.");
+      }
+      pop(); // Type arguments.
+      var e = popForValue(); // Expression.
+      constantExpressionRequired = pop();
+      push(e);
+    }
   }
 
   @override
   void endMetadataStar(int count, bool forParameter) {
     debugEvent("MetadataStar");
-    push(NullValue.Metadata);
+    push(popList(count) ?? NullValue.Metadata);
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
     doFields(count);
-    // There's no metadata here because of a slight asymmetry between
-    // [parseTopLevelMember] and [parseMember]. This asymmetry leads to
-    // DietListener discarding top-level member metadata.
   }
 
   @override
   void endFields(int count, Token beginToken, Token endToken) {
     debugEvent("Fields");
     doFields(count);
-    pop(); // Metadata.
   }
 
   void doFields(int count) {
+    List<FieldBuilder> fields = <FieldBuilder>[];
     for (int i = 0; i < count; i++) {
       Expression initializer = pop();
       Identifier identifier = pop();
+      String name = identifier.name;
+      FieldBuilder field;
+      if (classBuilder != null) {
+        field = classBuilder[name];
+      } else {
+        field = library[name];
+      }
+      fields.add(field);
       if (initializer != null) {
-        String name = identifier.name;
-        FieldBuilder field;
-        if (classBuilder != null) {
-          field = classBuilder[name];
-        } else {
-          field = library[name];
-        }
         if (field.next != null) {
           // TODO(ahe): This can happen, for example, if a final field is
           // combined with a setter.
           internalError(
               "Unhandled: '${field.name}' has more than one declaration.");
         }
         field.initializer = initializer;
         _typeInferrer.inferFieldInitializer(field.builtType, initializer);
       }
     }
     pop(); // Type.
     pop(); // Modifiers.
+    List annotations = pop();
+    if (annotations != null) {
+      Field field = fields.first.target;
+      // The first (and often only field) will not get a clone.
+      annotations.forEach(field.addAnnotation);
+      for (int i = 1; i < fields.length; i++) {
+        // We have to clone the annotations on the remaining fields.
+        field = fields[i].target;
+        cloner ??= new CloneVisitor();
+        for (Expression annotation in annotations) {
+          field.addAnnotation(cloner.clone(annotation));
+        }
+      }
+    }
   }
 
   @override
   void endMember() {
     debugEvent("Member");
     checkEmpty(-1);
   }
 
   @override
   void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
@@ skipping 102 matching lines @@
   DartType _computeReturnTypeContext(MemberBuilder member) {
     if (member is KernelProcedureBuilder) {
       return member.target.function.returnType;
     } else {
       assert(member is KernelConstructorBuilder);
       return null;
     }
   }
 
   @override
-  void finishFunction(
-      FormalParameters formals, AsyncMarker asyncModifier, Statement body) {
+  void finishFunction(List annotations, FormalParameters formals,
+      AsyncMarker asyncModifier, Statement body) {
     debugEvent("finishFunction");
     typePromoter.finished();
     _typeInferrer.inferFunctionBody(
         _computeReturnTypeContext(member), asyncModifier, body);
     KernelFunctionBuilder builder = member;
     builder.body = body;
+    Member target = builder.target;
+    for (Expression annotation in annotations ?? const []) {
+      target.addAnnotation(annotation);
+    }
     if (formals?.optional != null) {
       Iterator<FormalParameterBuilder> formalBuilders =
           builder.formals.skip(formals.required.length).iterator;
       for (VariableDeclaration parameter in formals.optional.formals) {
         bool hasMore = formalBuilders.moveNext();
         assert(hasMore);
         VariableDeclaration realParameter = formalBuilders.current.target;
         Expression initializer =
             parameter.initializer ?? new KernelNullLiteral();
         _typeInferrer.inferParameterInitializer(
@@ skipping 1667 matching lines @@
             // means that it is unresolved. So we set target to null so we
             // can generate a no-such-method error below.
             assert(body.isUnresolved);
             target = null;
             errorName = body.unresolvedName;
           }
         }
         if (target is Constructor ||
             (target is Procedure && target.kind == ProcedureKind.Factory)) {
           push(buildStaticInvocation(target, arguments,
-              isConst: optional("const", token),
+              isConst: optional("const", token) || optional("@", token),
               charOffset: nameToken.charOffset,
               initialTarget: initialTarget));
           return;
         } else {
           errorName ??= debugName(type.name, name);
         }
       } else {
         errorName = debugName(getNodeName(type), name);
       }
       errorName ??= name;
@@ skipping 1360 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }