Create ElementAnnotation objects prior to resolution.

pkg/analyzer/lib/src/dart/element/builder.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 44 matching lines @@
       holder.validate();
       return element;
     });
   }
 }
 
 /**
  * Instances of the class `DirectiveElementBuilder` build elements for top
  * level library directives.
  */
-class DirectiveElementBuilder extends SimpleAstVisitor<Object> {
+class DirectiveElementBuilder extends SimpleAstVisitor<Object>
+    with _ElementBuilderMixin {
   /**
    * The analysis context within which directive elements are being built.
    */
   final AnalysisContext context;
 
   /**
    * The library element for which directive elements are being built.
    */
   final LibraryElementImpl libraryElement;
 
@@ skipping 103 matching lines @@
         node.element = exportElement;
         exports.add(exportElement);
         if (exportSourceKindMap[exportedSource] != SourceKind.LIBRARY) {
           errors.add(new AnalysisError(
               exportedSource,
               uriLiteral.offset,
               uriLiteral.length,
               CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
               [uriLiteral.toSource()]));
         }
+        setMetadata(exportElement, node);
       }
     }
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     String uriContent = node.uriContent;
     if (DartUriResolver.isDartExtUri(uriContent)) {
       libraryElement.hasExtUri = true;
@@ skipping 32 matching lines @@
         }
         node.element = importElement;
         imports.add(importElement);
         if (importSourceKindMap[importedSource] != SourceKind.LIBRARY) {
           ErrorCode errorCode = (importElement.isDeferred
               ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
               : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
           errors.add(new AnalysisError(importedSource, uriLiteral.offset,
               uriLiteral.length, errorCode, [uriLiteral.toSource()]));
         }
+        setMetadata(importElement, node);
       }
     }
     return null;
   }
 
+  @override
+  Object visitLibraryDirective(LibraryDirective node) {
+    setMetadata(node.element, node);
+    return null;
+  }
+
+  @override
+  Object visitPartDirective(PartDirective node) {
+    setMetadata(node.element, node);
+    return null;
+  }
+
+  @override
+  Object visitPartOfDirective(PartOfDirective node) {
+    setMetadata(node.element, node);
+    return null;
+  }
+
   /**
    * If the given [node] has a documentation comment, remember its content
    * and range into the given [element].
    */
   void _setDoc(ElementImpl element, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null && comment.isDocumentation) {
       element.documentationComment =
           comment.tokens.map((Token t) => t.lexeme).join('\n');
       element.setDocRange(comment.offset, comment.length);
@@ skipping 12 matching lines @@
       combinator.accept(namespaceCombinatorBuilder);
     }
     return namespaceCombinatorBuilder.combinators;
   }
 }
 
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  */
-class ElementBuilder extends RecursiveAstVisitor<Object> {
+class ElementBuilder extends RecursiveAstVisitor<Object>
+    with _ElementBuilderMixin {
   /**
    * The element holder associated with the element that is currently being built.
    */
   ElementHolder _currentHolder;
 
   /**
    * A flag indicating whether a variable declaration is in the context of a field declaration.
    */
   bool _inFieldContext = false;
 
@@ skipping 104 matching lines @@
     // Function types must be initialized after the enclosing element has been
     // set, for them to pick up the type parameters.
     for (ExecutableElementImpl e in _functionTypesToFix) {
       e.type = new FunctionTypeImpl(e);
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
     _fieldMap = null;
     holder.validate();
+    setMetadata(element, node);
     return null;
   }
 
   /**
    * Implementation of this method should be synchronized with
    * [visitClassDeclaration].
    */
   void visitClassDeclarationIncrementally(ClassDeclaration node) {
     //
     // Process field declarations before constructors and methods so that field
@@ skipping 14 matching lines @@
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     element.typeParameters = typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     _setDoc(element, node);
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
+    setMetadata(element, node);
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
@@ skipping 29 matching lines @@
       if (returnType != null) {
         element.nameOffset = returnType.offset;
         element.nameEnd = returnType.end;
       }
     } else {
       constructorName.staticElement = element;
       element.periodOffset = node.period.offset;
       element.nameEnd = constructorName.end;
     }
     holder.validate();
+    setMetadata(element, node);
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     LocalVariableElementImpl element =
         new LocalVariableElementImpl.forNode(variableName);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
     element.const3 = node.isConst;
     element.final2 = node.isFinal;
     if (node.type == null) {
       element.hasImplicitType = true;
     }
     _currentHolder.addLocalVariable(element);
     variableName.staticElement = element;
+    setMetadata(element, node);
     return super.visitDeclaredIdentifier(node);
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     NormalFormalParameter normalParameter = node.parameter;
     SimpleIdentifier parameterName = normalParameter.identifier;
     ParameterElementImpl parameter;
     if (normalParameter is FieldFormalParameter) {
@@ skipping 44 matching lines @@
     _setDoc(enumElement, node);
     InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     // The equivalent code for enums in the spec shows a single constructor,
     // but that constructor is not callable (since it is a compile-time error
     // to subclass, mix-in, implement, or explicitly instantiate an enum).  So
     // we represent this as having no constructors.
     enumElement.constructors = ConstructorElement.EMPTY_LIST;
     _currentHolder.addEnum(enumElement);
     enumName.staticElement = enumElement;
+    setMetadata(enumElement, node);
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
     try {
       node.visitChildren(this);
     } finally {
@@ skipping 22 matching lines @@
     //
     // The children of this parameter include any parameters defined on the type
     // of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     ParameterElementImpl element = node.element;
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
+    _setMetadataForParameter(element, node);
     return null;
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
@@ skipping 30 matching lines @@
             int blockEnd = enclosingBlock.offset + enclosingBlock.length;
             element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
           }
         }
         if (node.returnType == null) {
           element.hasImplicitReturnType = true;
         }
         _currentHolder.addFunction(element);
         expression.element = element;
         functionName.staticElement = element;
+        setMetadata(element, node);
       } else {
         SimpleIdentifier propertyNameNode = node.name;
         if (propertyNameNode == null) {
           // TODO(brianwilkerson) Report this internal error.
           return null;
         }
         String propertyName = propertyNameNode.name;
         TopLevelVariableElementImpl variable = _currentHolder
             .getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
@@ skipping 21 matching lines @@
           getter.variable = variable;
           getter.getter = true;
           getter.static = true;
           variable.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           expression.element = getter;
           propertyNameNode.staticElement = getter;
+          setMetadata(getter, node);
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
           _setDoc(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
             setter.asynchronous = true;
           }
           if (body.isGenerator) {
             setter.generator = true;
           }
           setter.variable = variable;
           setter.setter = true;
           setter.static = true;
           if (node.returnType == null) {
             setter.hasImplicitReturnType = true;
           }
           variable.setter = setter;
           variable.final2 = false;
           _currentHolder.addAccessor(setter);
           expression.element = setter;
           propertyNameNode.staticElement = setter;
+          setMetadata(setter, node);
         }
       }
       holder.validate();
     }
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
@@ skipping 53 matching lines @@
     FunctionTypeAliasElementImpl element =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
     _setDoc(element, node);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
     _createTypeParameterTypes(typeParameters);
     element.type = new FunctionTypeImpl.forTypedef(element);
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
+    setMetadata(element, node);
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
     //of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     ParameterElementImpl element = node.element;
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
+    _setMetadataForParameter(element, node);
     return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element =
           new LabelElementImpl(labelName, onSwitchStatement, false);
@@ skipping 41 matching lines @@
           element.asynchronous = true;
         }
         if (body.isGenerator) {
           element.generator = true;
         }
         if (node.returnType == null) {
           element.hasImplicitReturnType = true;
         }
         _currentHolder.addMethod(element);
         methodName.staticElement = element;
+        setMetadata(element, node);
       } else {
         SimpleIdentifier propertyNameNode = node.name;
         String propertyName = propertyNameNode.name;
         FieldElementImpl field =
             _currentHolder.getField(propertyName) as FieldElementImpl;
         if (field == null) {
           field = new FieldElementImpl(node.name.name, -1);
           field.final2 = true;
           field.static = isStatic;
           field.synthetic = true;
@@ skipping 18 matching lines @@
           getter.variable = field;
           getter.abstract = node.isAbstract;
           getter.getter = true;
           getter.static = isStatic;
           field.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           propertyNameNode.staticElement = getter;
+          setMetadata(getter, node);
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
           _setDoc(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
             setter.asynchronous = true;
           }
           if (body.isGenerator) {
             setter.generator = true;
           }
           setter.variable = field;
           setter.abstract = node.isAbstract;
           setter.setter = true;
           setter.static = isStatic;
           if (node.returnType == null) {
             setter.hasImplicitReturnType = true;
           }
           field.setter = setter;
           field.final2 = false;
           _currentHolder.addAccessor(setter);
           propertyNameNode.staticElement = setter;
+          setMetadata(setter, node);
         }
       }
       holder.validate();
     } catch (exception, stackTrace) {
       if (node.name.staticElement == null) {
         ClassDeclaration classNode =
             node.getAncestor((node) => node is ClassDeclaration);
         StringBuffer buffer = new StringBuffer();
         buffer.write("The element for the method ");
         buffer.write(node.name);
@@ skipping 36 matching lines @@
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       if (node.type == null) {
         parameter.hasImplicitType = true;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
-    return super.visitSimpleFormalParameter(node);
+    super.visitSimpleFormalParameter(node);
+    _setMetadataForParameter(node.element, node);
+    return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, false, true);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
@@ skipping 14 matching lines @@
   @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElementImpl typeParameter =
         new TypeParameterElementImpl.forNode(parameterName);
     TypeParameterTypeImpl typeParameterType =
         new TypeParameterTypeImpl(typeParameter);
     typeParameter.type = typeParameterType;
     _currentHolder.addTypeParameter(typeParameter);
     parameterName.staticElement = typeParameter;
+    setMetadata(typeParameter, node);
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     bool isConst = node.isConst;
     bool isFinal = node.isFinal;
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
@@ skipping 88 matching lines @@
         setter.setter = true;
         ParameterElementImpl parameter =
             new ParameterElementImpl("_${element.name}", element.nameOffset);
         parameter.synthetic = true;
         parameter.parameterKind = ParameterKind.REQUIRED;
         setter.parameters = <ParameterElement>[parameter];
         _currentHolder.addAccessor(setter);
         element.setter = setter;
       }
     }
+    setMetadata(element, node);
     return null;
   }
 
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
    */
   void _buildFieldMap(List<FieldElement> fields) {
@@ skipping 144 matching lines @@
   Object visitMethodDeclaration(MethodDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(builder);
 }
 
 /**
+ * Helper methods used by element builder classes.
+ */
+class _ElementBuilderMixin {
+  /**
+   * Given a [node] that can have annotations associated with it and the
+   * [element] to which that node has been resolved, create the annotations in
+   * the element model representing the annotations on the node.
+   */
+  void setMetadata(Element element, AnnotatedNode node) {
+    if (element is! ElementImpl) {
+      return;
+    }
+    List<ElementAnnotationImpl> annotationList = <ElementAnnotationImpl>[];
+    _addAnnotations(annotationList, node.metadata, element);
+    if (node is VariableDeclaration && node.parent is VariableDeclarationList) {
+      VariableDeclarationList list = node.parent as VariableDeclarationList;
+      _addAnnotations(annotationList, list.metadata, element);
+      if (list.parent is FieldDeclaration) {
+        FieldDeclaration fieldDeclaration = list.parent as FieldDeclaration;
+        _addAnnotations(annotationList, fieldDeclaration.metadata, element);
+      } else if (list.parent is TopLevelVariableDeclaration) {
+        TopLevelVariableDeclaration variableDeclaration =
+            list.parent as TopLevelVariableDeclaration;
+        _addAnnotations(annotationList, variableDeclaration.metadata, element);
+      }
+    }
+    if (!annotationList.isEmpty) {
+      (element as ElementImpl).metadata = annotationList;
+    }
+  }
+
+  /**
+   * Given a [node] that can have annotations associated with it and the
+   * [element] to which that node has been resolved, create the annotations in
+   * the element model representing the annotations on the node.
+   */
+  void _setMetadataForParameter(Element element, NormalFormalParameter node) {
+    if (element is! ElementImpl) {
+      return;
+    }
+    List<ElementAnnotationImpl> annotationList =
+        new List<ElementAnnotationImpl>();
+    _addAnnotations(annotationList, node.metadata, element);
+    if (!annotationList.isEmpty) {
+      (element as ElementImpl).metadata = annotationList;
+    }
+  }
+
+  /**
+   * Generate annotation elements for each of the annotations in the
+   * [annotationList] and add them to the given list of [annotations].
+   *
+   * [annotatedElement] is the element to which the annotations are being
+   * applied.
+   */
+  static void _addAnnotations(List<ElementAnnotationImpl> annotationList,
+      NodeList<Annotation> annotations, Element annotatedElement) {
+    int annotationCount = annotations.length;
+    for (int i = 0; i < annotationCount; i++) {
+      Annotation annotation = annotations[i];
+      ElementAnnotationImpl elementAnnotation =
+          new ElementAnnotationImpl(annotatedElement);
+      annotation.elementAnnotation = elementAnnotation;
+      annotationList.add(elementAnnotation);
+    }
+  }
+}
+
+/**
  * Instances of the class [_NamespaceCombinatorBuilder] can be used to visit
  * [Combinator] AST nodes and generate [NamespaceCombinator] elements.
  */
 class _NamespaceCombinatorBuilder extends SimpleAstVisitor<Object> {
   /**
    * Elements generated so far.
    */
   final List<NamespaceCombinator> combinators = <NamespaceCombinator>[];
 
   @override
@@ skipping 14 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }