Make DeclarationResolver re-associate Annotations with ElementAnnotations.

pkg/analyzer/lib/src/generated/resolver.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.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 2079 matching lines @@
     }
     return super.visitCatchClause(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
-      return super.visitClassDeclaration(node);
+      super.visitClassDeclaration(node);
+      _resolveMetadata(node.metadata, _enclosingClass.metadata);
+      return null;
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
-      return super.visitClassTypeAlias(node);
+      super.visitClassTypeAlias(node);
+      _resolveMetadata(node.metadata, _enclosingClass.metadata);
+      return null;
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
       } else {
         _enclosingExecutable =
             _enclosingClass.getNamedConstructor(constructorName.name);
         constructorName.staticElement = _enclosingExecutable;
       }
       node.element = _enclosingExecutable as ConstructorElement;
-      return super.visitConstructorDeclaration(node);
+      super.visitConstructorDeclaration(node);
+      _resolveMetadata(node.metadata, _enclosingExecutable.metadata);
+      return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    _findIdentifier(_enclosingExecutable.localVariables, variableName);
-    return super.visitDeclaredIdentifier(node);
+    Element element =
+        _findIdentifier(_enclosingExecutable.localVariables, variableName);
+    super.visitDeclaredIdentifier(node);
+    _resolveMetadata(node.metadata, element.metadata);
+    return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElement element = _getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
           // TODO(brianwilkerson) Report this internal error.
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
-      return super.visitDefaultFormalParameter(node);
+      super.visitDefaultFormalParameter(node);
+      _resolveMetadata(node.metadata, element.metadata);
+      return null;
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     ClassElement enclosingEnum =
         _findIdentifier(_enclosingUnit.enums, node.name);
     List<FieldElement> constants = enclosingEnum.fields;
     for (EnumConstantDeclaration constant in node.constants) {
       _findIdentifier(constants, constant.name);
     }
-    return super.visitEnumDeclaration(node);
+    super.visitEnumDeclaration(node);
+    _resolveMetadata(node.metadata, enclosingEnum.metadata);
+    return null;
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     String uri = _getStringValue(node.uri);
+    ExportElement exportElement;
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = _findExport(
+      exportElement = _findExport(
           library.exports,
           _enclosingUnit.context.sourceFactory
               .resolveUri(_enclosingUnit.source, uri));
       node.element = exportElement;
     }
-    return super.visitExportDirective(node);
+    super.visitExportDirective(node);
+    if (exportElement != null) {
+      _resolveMetadata(node.metadata, exportElement.metadata);
+    }
+    return null;
   }
 
   @override
+  Object visitFieldDeclaration(FieldDeclaration node) {
+    super.visitFieldDeclaration(node);
+    _resolveMetadata(node.metadata, node.fields.variables[0].element.metadata);
+    return null;
+  }
+
+  @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        return super.visitFieldFormalParameter(node);
+        super.visitFieldFormalParameter(node);
+        _resolveMetadata(node.metadata, element.metadata);
+        return null;
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
@@ skipping 17 matching lines @@
           PropertyAccessorElement accessor =
               _findIdentifier(_enclosingUnit.accessors, functionName);
           if ((property as KeywordToken).keyword == Keyword.SET) {
             accessor = accessor.variable.setter;
             functionName.staticElement = accessor;
           }
           _enclosingExecutable = accessor;
         }
       }
       node.functionExpression.element = _enclosingExecutable;
-      return super.visitFunctionDeclaration(node);
+      super.visitFunctionDeclaration(node);
+      _resolveMetadata(node.metadata, _enclosingExecutable.metadata);
+      return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       FunctionElement element =
           _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
       node.element = element;
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
       return super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
       _enclosingAlias =
           _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
-      return super.visitFunctionTypeAlias(node);
+      super.visitFunctionTypeAlias(node);
+      _resolveMetadata(node.metadata, _enclosingAlias.metadata);
+      return null;
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        return super.visitFunctionTypedFormalParameter(node);
+        super.visitFunctionTypedFormalParameter(node);
+        _resolveMetadata(node.metadata, _enclosingParameter.metadata);
+        return null;
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
+    ImportElement importElement;
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = _findImport(
+      importElement = _findImport(
           library.imports,
           _enclosingUnit.context.sourceFactory
               .resolveUri(_enclosingUnit.source, uri),
           node.prefix);
       node.element = importElement;
     }
-    return super.visitImportDirective(node);
+    super.visitImportDirective(node);
+    if (importElement != null) {
+      _resolveMetadata(node.metadata, importElement.metadata);
+    }
+    return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitLabeledStatement(node);
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
-    node.element = _enclosingUnit.library;
-    return super.visitLibraryDirective(node);
+    LibraryElement libraryElement = _enclosingUnit.library;
+    node.element = libraryElement;
+    super.visitLibraryDirective(node);
+    _resolveMetadata(node.metadata, libraryElement.metadata);
+    return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (property == null) {
         _enclosingExecutable = _findWithNameAndOffset(
             _enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingClass.accessors, methodName);
         if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
-      return super.visitMethodDeclaration(node);
+      super.visitMethodDeclaration(node);
+      _resolveMetadata(node.metadata, _enclosingExecutable.metadata);
+      return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
+    CompilationUnitElement compilationUnitElement;
     if (uri != null) {
       Source partSource = _enclosingUnit.context.sourceFactory
           .resolveUri(_enclosingUnit.source, uri);
-      node.element = _findPart(_enclosingUnit.library.parts, partSource);
+      compilationUnitElement =
+          _findPart(_enclosingUnit.library.parts, partSource);
+      node.element = compilationUnitElement;
     }
-    return super.visitPartDirective(node);
+    super.visitPartDirective(node);
+    if (compilationUnitElement != null) {
+      _resolveMetadata(node.metadata, compilationUnitElement.metadata);

[Brian Wilkerson, 2016/02/04 19:44:52]

Do we want to do this here? I think the compilation unit element is the one
associated with the part. Won't we end up with a similar problem as 'part of'
directives if we have parts being included in multiple libraries?

[Paul Berry, 2016/02/04 20:17:41]

I don't think it will be a problem, because if a single part file is included in
N libraries, N separate CompilationUnitElements are created, one for each
library.

+    }
+    return null;
   }
 
   @override
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        return super.visitSimpleFormalParameter(node);
+        super.visitSimpleFormalParameter(node);
+        _resolveMetadata(node.metadata, element.metadata);
+        return null;
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {}
     return super.visitSimpleFormalParameter(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchCase(node);
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchDefault(node);
   }
 
   @override
+  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    super.visitTopLevelVariableDeclaration(node);
+    _resolveMetadata(
+        node.metadata, node.variables.variables[0].element.metadata);
+    return null;
+  }
+
+  @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
 
     Element element;
     if (_enclosingExecutable != null) {
       element =
           _findIdentifier(_enclosingExecutable.typeParameters, parameterName);
     }
     if (element == null) {
       if (_enclosingClass != null) {
-        _findIdentifier(_enclosingClass.typeParameters, parameterName);
+        element =
+            _findIdentifier(_enclosingClass.typeParameters, parameterName);
       } else if (_enclosingAlias != null) {
-        _findIdentifier(_enclosingAlias.typeParameters, parameterName);
+        element =
+            _findIdentifier(_enclosingAlias.typeParameters, parameterName);
       }
     }
-    return super.visitTypeParameter(node);
+    super.visitTypeParameter(node);
+    _resolveMetadata(node.metadata, element.metadata);
+    return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = null;
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
       element =
           _findIdentifier(_enclosingExecutable.localVariables, variableName);
     }
@@ skipping 13 matching lines @@
           _enclosingExecutable = element.initializer;
         }
         return super.visitVariableDeclaration(node);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     return super.visitVariableDeclaration(node);
   }
 
+  @override
+  Object visitVariableDeclarationList(VariableDeclarationList node) {
+    super.visitVariableDeclarationList(node);
+    if (node.parent is! FieldDeclaration &&
+        node.parent is! TopLevelVariableDeclaration) {
+      _resolveMetadata(node.metadata, node.variables[0].element.metadata);
+    }
+    return null;
+  }
+
   /**
    * Return the element in the given array of elements that was created for the declaration at the
    * given offset. This method should only be used when there is no name
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param offset the offset of the name of the element to be returned
    * @return the element at the given offset
    */
   Element _findAtOffset(List<Element> elements, int offset) =>
       _findWithNameAndOffset(elements, "", offset);
@@ skipping 143 matching lines @@
    *
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
   String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
+
+  void _resolveMetadata(NodeList<Annotation> astMetadata,
+      List<ElementAnnotation> elementMetadata) {
+    assert(astMetadata.length == elementMetadata.length);
+    for (int i = 0; i < astMetadata.length; i++) {
+      astMetadata[i].elementAnnotation = elementMetadata[i];
+    }
+  }
 }
 
 /**
  * Instances of the class `ElementHolder` hold on to elements created while traversing an AST
  * structure so that they can be accessed when creating their enclosing element.
  */
 class ElementHolder {
   List<PropertyAccessorElement> _accessors;
 
   List<ConstructorElement> _constructors;
@@ skipping 9878 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }