Handle metadata on nested function parameters.

sdk/lib/_internal/compiler/implementation/elements/elements.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 elements;
 
 
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 368 matching lines @@
   bool isForeign(Compiler compiler);
 
   void addMetadata(MetadataAnnotation annotation);
   void setNative(String name);
   void setFixedBackendName(String name);
 
   Scope buildScope();
 
   void diagnose(Element context, DiagnosticListener listener);
 
-  TreeElements get treeElements;
+  // TODO(johnniwinther): Move this to [AstElement].
+  /// Returns the [Element] that holds the [TreeElements] for this element.
+  AnalyzableElement get analyzableElement;
 
   accept(ElementVisitor visitor);
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
     return e == null || e.isErroneous;
   }
   static bool isErroneousElement(Element e) => e != null && e.isErroneous;
 
@@ skipping 375 matching lines @@
   PartOf get partTag;
 
   void forEachLocalMember(f(Element element));
   void addMember(Element element, DiagnosticListener listener);
   void setPartOf(PartOf tag, DiagnosticListener listener);
   bool get hasMembers;
 
   int compareTo(CompilationUnitElement other);
 }
 
-abstract class LibraryElement extends Element implements ScopeContainerElement {
+abstract class LibraryElement extends Element
+    implements ScopeContainerElement, AnalyzableElement {
   /**
    * The canonical uri for this library.
    *
    * For user libraries the canonical uri is the script uri. For platform
    * libraries the canonical uri is of the form [:dart:x:].
    */
   Uri get canonicalUri;
   CompilationUnitElement get entryCompilationUnit;
   Link<CompilationUnitElement> get compilationUnits;
   Link<LibraryTag> get tags;
@@ skipping 423 matching lines @@
 }
 
 abstract class MetadataAnnotation implements Spannable {
   /// The front-end constant of this metadata annotation.
   Constant get value;
   Element get annotatedElement;
   int get resolutionState;
   Token get beginToken;
   Token get endToken;
 
-  // TODO(kasperl): Try to get rid of these.
-  void set annotatedElement(Element value);
-
   MetadataAnnotation ensureResolved(Compiler compiler);
 }
 
 /// An [Element] that has a type.
 abstract class TypedElement extends Element {
   DartType get type;
 }
 
 /// An [Element] that can define a function type.
 abstract class FunctionTypedElement extends Element {
   /// The function signature for the function type defined by this element,
   /// if any.
   FunctionSignature get functionSignature;
 }
 
+/// An [Element] that holds a [TreeElements] mapping.
+abstract class AnalyzableElement extends Element {
+  /// Returns the [TreeElements] that hold the resolution information for the
+  /// AST nodes of this element.
+  TreeElements get treeElements;
+}
+
 /// An [Element] that (potentially) has a node.
 ///
 /// Synthesized elements may return `null` from [node].
-abstract class AstElement extends Element {
+abstract class AstElement extends AnalyzableElement {
   Node get node;
 }
 
 /// A [MemberSignature] is a member of an interface.
 ///
 /// A signature is either a method or a getter or setter, possibly implicitly
 /// defined by a field declarations. Fields themselves are not members of an
 /// interface.
 ///
 /// A [MemberSignature] may be defined by a member declaration or may be
@@ skipping 63 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }