Add type inference of annotations.

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 428 matching lines @@
         }
         field.initializer = initializer;
         _typeInferrer.inferFieldInitializer(
             field.hasImplicitType ? null : field.builtType, initializer);
       }
     }
     pop(); // Type.
     pop(); // Modifiers.
     List annotations = pop();
     if (annotations != null) {
+      _typeInferrer.inferMetadata(annotations);

[ahe, 2017/06/28 07:39:49]

Can you move all these calls to endMetadataStar? And then remove finishMetadata?

[Paul Berry, 2017/06/28 12:15:59]

I could do that now, but it would not work in the long term.  Once we have
support for annotations on local variables and local functions (see
https://github.com/dart-lang/sdk/issues/30031 and
https://github.com/dart-lang/sdk/issues/30035), we will have to ensure that type
inference for local annotations happens during the type inference phase, so that
code like this will infer correctly:

  class Foo {
    const Foo(dynamic x);
  }
  void test() {
    const x = 0; // Infers as: const int x = 0;
    @Foo([x]) // Infers as: @Foo(<int>[x])
    int y;
  }

Leaving as is for now.  If you have strong feelings about this, let me know and
we can discuss.

       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));
         }
@@ skipping 123 matching lines @@
   @override
   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;
+    _typeInferrer.inferMetadata(annotations);
     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(
             initializer, realParameter.type);
         realParameter.initializer = initializer..parent = realParameter;
       }
     }
     if (builder is KernelConstructorBuilder) {
       finishConstructor(builder, asyncModifier);
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
   }
 
+  @override
+  List<Expression> finishMetadata() {
+    List<Expression> expressions = pop();
+    _typeInferrer.inferMetadata(expressions);
+    return expressions;
+  }
+
   void finishConstructor(
       KernelConstructorBuilder builder, AsyncMarker asyncModifier) {
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// https://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf).
     assert(builder == member);
     Constructor constructor = builder.constructor;
     if (asyncModifier != AsyncMarker.Sync) {
       // TODO(ahe): Change this to a null check.
       int offset = builder.body?.fileOffset ?? builder.charOffset;
@@ skipping 3067 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }