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;
+  int resolutionState = STATE_NOT_STARTED;
 
   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;
   }
 
   /**
    * Function signature for a typedef of a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
   TypedefType computeType(Compiler compiler) {
     if (thisTypeCache != null) return thisTypeCache;
     Typedef node = parseNode(compiler);
     setThisAndRawTypes(compiler, createTypeVariables(node.typeParameters));
-    compiler.resolveTypedef(this);
+    ensureResolved(compiler);
     return thisTypeCache;
   }
 
+  void ensureResolved(Compiler compiler) {
+    if (resolutionState == STATE_NOT_STARTED) {
+      compiler.resolver.resolve(this);
+    }
+  }
+
   TypedefType createType(Link<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Compiler compiler) {
     if (hasBeenCheckedForCycles) return;
@@ skipping 22 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 341 matching lines @@
       TypeVariable node = link.head;
       String variableName = node.name.source;
       TypeVariableElementX variableElement =
           new TypeVariableElementX(variableName, this, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.typeCache = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
+
+  bool get isResolved => resolutionState == STATE_DONE;
 }
 
 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;
   int resolutionState;
-  bool get isResolved => resolutionState == STATE_DONE;
   bool isProxy = false;
   bool hasIncompleteHierarchy = false;
 
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const Link<Element>();
 
   OrderedTypeSet allSupertypesAndSelf;
 
   Link<DartType> get allSupertypes => allSupertypesAndSelf.supertypes;
@@ skipping 708 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;
   }
 }