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 120 matching lines @@
    */
   Element get enclosingMember {
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isMember) return e;
     }
     return null;
   }
 
   Element get outermostEnclosingMemberOrTopLevel {
     // TODO(lrn): Why is this called "Outermost"?
+    // TODO(johnniwinther): Clean up this method: This method does not return
+    // the outermost for elements in closure classses, but some call-sites rely
+    // on that behavior.
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isMember || e.isTopLevel) {
         return e;
       }
     }
     return null;
   }
 
   ClassElement get contextClass {
     ClassElement cls;
@@ skipping 40 matching lines @@
     _fixedBackendName = name;
   }
 
   FunctionElement asFunctionElement() => null;
 
   bool get isAbstract => modifiers.isAbstract;
   bool isForeign(Compiler compiler) => library == compiler.foreignLibrary;
 
   void diagnose(Element context, DiagnosticListener listener) {}
 
-  TreeElements get treeElements => enclosingElement.treeElements;
+  TreeElements get treeElements => analyzableElement.treeElements;
+
+  AnalyzableElement 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 260 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 91 matching lines @@
         importers.registerImport(ambiguousElement, import);
         importers.registerImport(ambiguousElement, existingImport);
       }
     }
   }
 
   Element operator [](String name) => importScope[name];
 }
 
 class LibraryElementX
-    extends ElementX with AnalyzableElement, PatchMixin<LibraryElementX>
+    extends ElementX with AnalyzableElementX, PatchMixin<LibraryElementX>
     implements LibraryElement {
   final Uri canonicalUri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const Link<CompilationUnitElement>();
   Link<LibraryTag> tags = const Link<LibraryTag>();
   LibraryName libraryTag;
   bool canUseNative = false;
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
@@ skipping 30 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 214 matching lines @@
   }
 
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
   void markAsDeferred(Import deferredImport) {
     _deferredImport = deferredImport;
   }
 }
 
 class TypedefElementX extends ElementX
-    with AnalyzableElement, TypeDeclarationElementX<TypedefType>
+    with AnalyzableElementX, TypeDeclarationElementX<TypedefType>
     implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type annotation which defines this typedef.
    */
   DartType alias;
 
   /// [:true:] if the typedef has been checked for cyclic reference.
   bool hasBeenCheckedForCycles = false;
 
   bool get isResolved => hasTreeElements;

[Johnni Winther, 2014/05/23 07:55:56]

The [TreeElements] can be created from resolution metadata on the typedef.

 
   TypedefElementX(String name, Element enclosing)
       : super(name, ElementKind.TYPEDEF, enclosing);
 
   Typedef get node {
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     return cachedNode;
   }
 
@@ skipping 50 matching lines @@
     assert(modifiers != null);
   }
 
   VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
     return definitions;
   }
 
   DartType computeType(Element element, Compiler compiler) => type;
 }
 
-class VariableElementX extends ElementX with AnalyzableElement
+class VariableElementX extends ElementX with AnalyzableElementX
     implements VariableElement {
   final Token token;
   final VariableList variables;
   VariableDefinitions definitionsCache;
   Expression initializerCache;
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElementX(String name,
                    ElementKind kind,
@@ skipping 335 matching lines @@
       // by call sites of a call to a method with the other signature.
       int otherTotalCount = signature.parameterCount;
       return requiredParameterCount <= otherTotalCount
           && parameterCount >= otherTotalCount;
     }
     return true;
   }
 }
 
 abstract class FunctionElementX
-    extends ElementX with AnalyzableElement, PatchMixin<FunctionElement>
+    extends ElementX with AnalyzableElementX, PatchMixin<FunctionElement>
     implements FunctionElement {
   DartType typeCache;
   final Modifiers modifiers;
 
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FunctionSignature functionSignatureCache;
 
   final bool _hasNoBody;
 
@@ skipping 344 matching lines @@
           new TypeVariableElementX(variableName, this, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.typeCache = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 abstract class BaseClassElementX extends ElementX
-    with AnalyzableElement,
+    with AnalyzableElementX,
          TypeDeclarationElementX<InterfaceType>,
          PatchMixin<ClassElement>,
          ClassMemberMixin
     implements ClassElement {
   final int id;
 
   DartType supertype;
   Link<DartType> interfaces;
   String nativeTagInfo;
   int supertypeLoadState;
@@ skipping 720 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;
   }
 }