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 240 matching lines @@
   GenericType get rawType;
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
    * [computeType].
    */
   Link<DartType> get typeVariables;
 
   bool get isResolved;
+
+  int get resolutionState;
+
+  void ensureResolved(Compiler compiler);
 }
 
 abstract class ClassElement extends TypeDeclarationElement
     implements ScopeContainerElement {
   int get id;
 
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
   InterfaceType get rawType;
@@ skipping 17 matching lines @@
 
   bool get hasConstructor;
   Link<Element> get constructors;
 
   ClassElement get patch;
   ClassElement get origin;
   ClassElement get declaration;
   ClassElement get implementation;
 
   int get supertypeLoadState;
-  int get resolutionState;
   String get nativeTagInfo;
 
   bool get isMixinApplication;
   bool get isUnnamedMixinApplication;
   bool get hasBackendMembers;
   bool get hasLocalScopeMembers;
 
-  // TODO(kasperl): These are bit fishy. Do we really need them?
-  void set supertype(DartType value);
-  void set interfaces(Link<DartType> value);
-  void set supertypeLoadState(int value);
-  void set resolutionState(int value);
-  void set nativeTagInfo(String value);
-
   bool isObject(Compiler compiler);
   bool isSubclassOf(ClassElement cls);
   /// Returns true if `this` explicitly/nominally implements [intrface].
   ///
   /// Note that, if [intrface] is the `Function` class, this method returns
   /// falso for a class that has a `call` method but does not explicitly
   /// implement `Function`.
   bool implementsInterface(ClassElement intrface);
   bool hasFieldShadowedBy(Element fieldMember);
 
   /// Returns `true` if this class has a @proxy annotation.
   bool get isProxy;
 
   /// Returns `true` if the class hierarchy for this class contains errors.
   bool get hasIncompleteHierarchy;
 
-  void ensureResolved(Compiler compiler);
-
   void addMember(Element element, DiagnosticListener listener);
   void addToScope(Element element, DiagnosticListener listener);
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
 
   void addBackendMember(Element element);
   void reverseBackendMembers();
 
   Element lookupMember(String memberName);
   Element lookupSelector(Selector selector, Compiler compiler);
@@ skipping 93 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;
 }