Support metadata on patches.

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;
@@ skipping 60 matching lines @@
     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 WorldImpact();
       }
 
       WorldImpact processMetadata([WorldImpact result]) {
-        for (MetadataAnnotation metadata in element.metadata) {
+        for (MetadataAnnotation metadata in element.implementation.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)) {
@@ skipping 495 matching lines @@
       // Stepwise assignment to ensure invariant.
       element.supertypeLoadState = STATE_STARTED;
       element.supertypeLoadState = STATE_DONE;
       element.resolutionState = STATE_DONE;
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
   }
 
   void _postProcessClassElement(BaseClassElementX element) {
-    for (MetadataAnnotation metadata in element.metadata) {
+    for (MetadataAnnotation metadata in element.implementation.metadata) {
       metadata.ensureResolved(compiler);
       ConstantValue value =
           compiler.constants.getConstantValue(metadata.constant);
       if (!element.isProxy && value == compiler.proxyConstant) {
         element.isProxy = true;
       }
     }
 
     // Force resolution of metadata on non-instance members since they may be
     // inspected by the backend while emitting. Metadata on instance members is
     // handled as a result of processing instantiated class members in the
     // enqueuer.
     // TODO(ahe): Avoid this eager resolution.
     element.forEachMember((_, Element member) {
       if (!member.isInstanceMember) {
         compiler.withCurrentElement(member, () {
-          for (MetadataAnnotation metadata in member.metadata) {
+          for (MetadataAnnotation metadata in member.implementation.metadata) {
             metadata.ensureResolved(compiler);
           }
         });
       }
     });
 
     computeClassMember(element, Identifiers.call);
   }
 
   void computeClassMembers(ClassElement element) {
@@ skipping 364 matching lines @@
       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.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, annotatedElement);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Spannable node, MessageKind kind, [arguments = const {}]) {
     compiler.reportError(node, kind, arguments);
   }
 
-  Link<MetadataAnnotation> resolveMetadata(Element element,
+  List<MetadataAnnotation> resolveMetadata(Element element,
                                            VariableDefinitions node) {
-    LinkBuilder<MetadataAnnotation> metadata =
-        new LinkBuilder<MetadataAnnotation>();
+    List<MetadataAnnotation> metadata = <MetadataAnnotation>[];
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
       metadataAnnotation.annotatedElement = element;
-      metadata.addLast(metadataAnnotation.ensureResolved(compiler));
+      metadata.add(metadataAnnotation.ensureResolved(compiler));
     }
-    return metadata.toLink();
+    return metadata;
   }
 }
 
 TreeElements _ensureTreeElements(AnalyzableElementX element) {
   if (element._treeElements == null) {
     element._treeElements = new TreeElementMapping(element);
   }
   return element._treeElements;
 }
 
 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;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }