Handle metadata on nested function parameters.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'elements.dart';
 import '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 43 matching lines @@
         'parseNode not implemented on $this.');
     return null;
   }
 
   DartType computeType(Compiler compiler) {
     compiler.internalError(this,
         "computeType not implemented on $this.");
     return null;
   }
 
-  void addMetadata(MetadataAnnotation annotation) {
+  void addMetadata(MetadataAnnotationX annotation) {
     assert(annotation.annotatedElement == null);
     annotation.annotatedElement = this;
     addMetadataInternal(annotation);
   }
 
   void addMetadataInternal(MetadataAnnotation annotation) {
     metadata = metadata.prepend(annotation);
   }
 
   bool get isClosure => false;
@@ skipping 118 matching lines @@
    * Returns the member enclosing this element or the element itself if it is a
    * member. If no enclosing element is found, [:null:] is returned.
    */
   Element get enclosingMember {
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isMember) return e;
     }
     return null;
   }
 
   Element get outermostEnclosingMemberOrTopLevel {

[karlklose, 2014/05/22 06:27:29]

Add a TODO to remove this helper or give it a better name (or at least a comment
answering lrn's question?

[Johnni Winther, 2014/05/22 10:09:09]

Done.

-    // TODO(lrn): Why is this called "Outermost"?
+    // TODO(johnniwinther): Fix this for members of a closure class.
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isMember || e.isTopLevel) {
         return e;
       }
     }
     return null;
   }
 
   ClassElement get contextClass {
     ClassElement cls;
@@ skipping 42 matching lines @@
 
   FunctionElement asFunctionElement() => null;
 
   bool get isAbstract => modifiers.isAbstract;
   bool isForeign(Compiler compiler) => library == compiler.foreignLibrary;
 
   FunctionElement get targetConstructor => null;
 
   void diagnose(Element context, DiagnosticListener listener) {}
 
-  TreeElements get treeElements => enclosingElement.treeElements;
+  TreeElements get treeElements => analyzableElement.treeElements;
+
+  Element get analyzableElement => outermostEnclosingMemberOrTopLevel;
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [:null:] to provide additional
  * information about the error that caused the element to be unresolvable
  * or otherwise invalid.
  *
  * Accessing any field or calling any method defined on [ErroneousElement]
@@ skipping 256 matching lines @@
       if (accessor.isGetter) {
         field.getter = accessor;
       } else {
         field.setter = accessor;
       }
       add(field, listener);
     }
   }
 }
 
-class CompilationUnitElementX extends ElementX with AnalyzableElement
+class CompilationUnitElementX extends ElementX
     implements CompilationUnitElement {
   final Script script;
   PartOf partTag;
   Link<Element> localMembers = const Link<Element>();
 
   CompilationUnitElementX(Script script, LibraryElement library)
     : this.script = script,
       super(script.name,
             ElementKind.COMPILATION_UNIT,
             library) {
@@ skipping 48 matching lines @@
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   int compareTo(CompilationUnitElement other) {
     if (this == other) return 0;
     return '${script.readableUri}'.compareTo('${other.script.readableUri}');
   }
 
+  Element get analyzableElement => library;
+
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
 }
 
 class Importers {
   Map<Element, Link<Import>> importers = new Map<Element, Link<Import>>();
 
   Link<Import> getImports(Element element) {
     Link<Import> imports = importers[element];
     return imports != null ? imports : const Link<Import>();
   }
@@ skipping 142 matching lines @@
     return (libraryTag == null) ? super.metadata : libraryTag.metadata;
   }
 
   set metadata(value) {
     // The metadata is stored on [libraryTag].
     throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
   }
 
   CompilationUnitElement get compilationUnit => entryCompilationUnit;
 
+  Element get analyzableElement => this;
+
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   void recordResolvedTag(LibraryDependency tag, LibraryElement library) {
     assert(tagMapping[tag] == null);
@@ skipping 1778 matching lines @@
     assert(invariant(this, this.origin == null,
                      message: "Origin element is a patch."));
     assert(invariant(patch, patch.origin == null,
                      message: "Element is patched twice."));
     assert(invariant(patch, patch.patch == null,
                      message: "Patch element is patched."));
     this.patch = patch;
     patch.origin = this;
   }
 }