Fixes to associating existing elements with an AST

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/token.dart';
@@ skipping 18 matching lines @@
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/task/strong/info.dart'
     show InferredType, StaticInfo;
 
 export 'package:analyzer/src/generated/type_system.dart';
 
 /**
+ * Throw an [ElementMismatchException] to report that the element model and the
+ * AST do not match. The [message] will have the path to the given [node]
+ * appended to it.
+ */
+void _mismatch(String message, AstNode node) {
+  StringBuffer buffer = new StringBuffer();
+  buffer.writeln(message);
+  buffer.write('Path to root:');
+  String separator = ' ';
+  AstNode parent = node;
+  while (parent != null) {
+    buffer.write(separator);
+    buffer.write(parent.runtimeType.toString());
+    separator = ', ';
+    parent = parent.parent;
+  }
+  throw new ElementMismatchException(buffer.toString());
+}
+
+/**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
   static String _NULL_TYPE_NAME = "Null";
 
   static String _TO_INT_METHOD_NAME = "toInt";
 
@@ skipping 2063 matching lines @@
   void _safelyVisit(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
 
 /**
  * A visitor that resolves declarations in an AST structure to already built
  * elements.
+ *
+ * The resulting AST must have everything resolved that would have been resolved
+ * by a [CompilationUnitBuilder] (that is, must be a valid [RESOLVED_UNIT1]).
+ * This class must not assume that the [CompilationUnitElement] passed to it is
+ * any more complete than a [COMPILATION_UNIT_ELEMENT].
  */
 class DeclarationResolver extends RecursiveAstVisitor<Object> {
   /**
    * The analysis context containing the sources to be analyzed.
    */
   AnalysisContext _context;
 
   /**
    * The elements that are reachable from the compilation unit element. When a
    * compilation unit has been resolved, this set should be empty.
    */
   Set<Element> _expectedElements;
 
   /**
    * The compilation unit containing the AST nodes being visited.
    */
-  CompilationUnitElement _enclosingUnit;
+  CompilationUnitElementImpl _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null`
    * if we are not in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not
    * in the scope of a class.
@@ skipping 44 matching lines @@
     return super.visitCatchClause(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       super.visitClassDeclaration(node);
-      _resolveMetadata(node.metadata, _enclosingClass);
+      _resolveMetadata(node, node.metadata, _enclosingClass);
       return null;
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       super.visitClassTypeAlias(node);
-      _resolveMetadata(node.metadata, _enclosingClass);
+      _resolveMetadata(node, node.metadata, _enclosingClass);
       return null;
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
         if (_enclosingExecutable == null) {
           _mismatch('Could not find default constructor', node);
         }
       } else {
         _enclosingExecutable =
             _enclosingClass.getNamedConstructor(constructorName.name);
         if (_enclosingExecutable == null) {
           _mismatch(
               'Could not find constructor element with name "${constructorName.name}',
               node);
         }
         constructorName.staticElement = _enclosingExecutable;
       }
       _expectedElements.remove(_enclosingExecutable);
       node.element = _enclosingExecutable as ConstructorElement;
       super.visitConstructorDeclaration(node);
-      _resolveMetadata(node.metadata, _enclosingExecutable);
+      _resolveMetadata(node, node.metadata, _enclosingExecutable);
       return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     Element element =
         _findIdentifier(_enclosingExecutable.localVariables, variableName);
     super.visitDeclaredIdentifier(node);
-    _resolveMetadata(node.metadata, element);
+    _resolveMetadata(node, node.metadata, element);
     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 {
         _enclosingExecutable = element.initializer;
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       super.visitDefaultFormalParameter(node);
-      _resolveMetadata(node.metadata, element);
+      _resolveMetadata(node, node.metadata, element);
       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);
     }
     super.visitEnumDeclaration(node);
-    _resolveMetadata(node.metadata, enclosingEnum);
+    _resolveMetadata(node, node.metadata, enclosingEnum);
     return null;
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
-    String uri = _getStringValue(node.uri);
-    ExportElement exportElement;
-    if (uri != null) {
-      LibraryElement library = _enclosingUnit.library;
-      Source source = _enclosingUnit.context.sourceFactory
-          .resolveUri(_enclosingUnit.source, uri);
-      exportElement = _findExport(node, library.exports, source);
-      node.element = exportElement;
-    }
     super.visitExportDirective(node);
-    _resolveMetadata(node.metadata, exportElement);
+    _resolveAnnotations(
+        node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     super.visitFieldDeclaration(node);
-    _resolveMetadata(node.metadata, node.fields.variables[0].element);
+    _resolveMetadata(node, node.metadata, node.fields.variables[0].element);
     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;
         super.visitFieldFormalParameter(node);
-        _resolveMetadata(node.metadata, element);
+        _resolveMetadata(node, node.metadata, element);
         return null;
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   @override
@@ skipping 28 matching lines @@
             accessor = _findWithNameAndOffset(accessors, functionName,
                 functionName.name + '=', functionName.offset);
             _expectedElements.remove(accessor);
             functionName.staticElement = accessor;
           }
           _enclosingExecutable = accessor;
         }
       }
       node.functionExpression.element = _enclosingExecutable;
       super.visitFunctionDeclaration(node);
-      _resolveMetadata(node.metadata, _enclosingExecutable);
+      _resolveMetadata(node, node.metadata, _enclosingExecutable);
       return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       FunctionElement element = _findAtOffset(
@@ skipping 11 matching lines @@
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
       _enclosingAlias =
           _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
       super.visitFunctionTypeAlias(node);
-      _resolveMetadata(node.metadata, _enclosingAlias);
+      _resolveMetadata(node, node.metadata, _enclosingAlias);
       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;
         super.visitFunctionTypedFormalParameter(node);
-        _resolveMetadata(node.metadata, _enclosingParameter);
+        _resolveMetadata(node, node.metadata, _enclosingParameter);
         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;
-      Source source = _enclosingUnit.context.sourceFactory
-          .resolveUri(_enclosingUnit.source, uri);
-      importElement = _findImport(node, library.imports, source);
-      node.element = importElement;
-    }
     super.visitImportDirective(node);
-    _resolveMetadata(node.metadata, importElement);
+    _resolveAnnotations(
+        node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     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) {
-    LibraryElement libraryElement = _enclosingUnit.library;
-    node.element = libraryElement;
     super.visitLibraryDirective(node);
-    _resolveMetadata(node.metadata, libraryElement);
+    _resolveAnnotations(
+        node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
@@ skipping 11 matching lines @@
           accessor = _findIdentifier(_enclosingClass.accessors, methodName);
         } else if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = _findWithNameAndOffset(_enclosingClass.accessors,
               methodName, nameOfMethod + '=', methodName.offset);
           _expectedElements.remove(accessor);
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       super.visitMethodDeclaration(node);
-      _resolveMetadata(node.metadata, _enclosingExecutable);
+      _resolveMetadata(node, node.metadata, _enclosingExecutable);
       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);
-      compilationUnitElement =
-          _findPart(_enclosingUnit.library.parts, node, partSource);
-    }
     super.visitPartDirective(node);
-    _resolveMetadata(node.metadata, compilationUnitElement);
+    _resolveAnnotations(
+        node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     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;
         super.visitSimpleFormalParameter(node);
-        _resolveMetadata(node.metadata, element);
+        _resolveMetadata(node, node.metadata, element);
         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);
+    _resolveMetadata(node, node.metadata, node.variables.variables[0].element);
     return null;
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     Element element = null;
     if (_enclosingExecutable != null) {
       element = _findIdentifier(
           _enclosingExecutable.typeParameters, parameterName,
           required: false);
     }
     if (element == null) {
       if (_enclosingClass != null) {
         element =
             _findIdentifier(_enclosingClass.typeParameters, parameterName);
       } else if (_enclosingAlias != null) {
         element =
             _findIdentifier(_enclosingAlias.typeParameters, parameterName);
       }
     }
     if (element == null) {
       String name = parameterName.name;
       int offset = parameterName.offset;
       _mismatch(
           'Could not find type parameter with name "$name" at $offset', node);
     }
     super.visitTypeParameter(node);
-    _resolveMetadata(node.metadata, element);
+    _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = null;
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
       element = _findIdentifier(
           _enclosingExecutable.localVariables, variableName,
@@ skipping 17 matching lines @@
       }
     }
     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);
+      _resolveMetadata(node, node.metadata, node.variables[0].element);
     }
     return null;
   }
 
   /**
    * Return the element in the given list of [elements] that was created for the
    * declaration at the given [offset]. Throw an [ElementMismatchException] if
    * an element at that offset cannot be found.
    *
    * This method should only be used when there is no name associated with the
    * node.
    */
   Element _findAtOffset(List<Element> elements, AstNode node, int offset) =>
       _findWithNameAndOffset(elements, node, '', offset);
 
   /**
-   * Return the export element from the given list of [exports] whose library
-   * has the given [source]. Throw an [ElementMismatchException] if an element
-   * corresponding to the identifier cannot be found.
-   */
-  ExportElement _findExport(
-      ExportDirective node, List<ExportElement> exports, Source source) {
-    if (source == null || !_context.exists(source)) {
-      return null;
-    }
-    for (ExportElement export in exports) {
-      if (export.exportedLibrary.source == source) {
-        return export;
-      }
-    }
-    _mismatch("Could not find export element for '$source'", node);
-    return null; // Never reached
-  }
-
-  /**
    * Return the element in the given list of [elements] that was created for the
    * declaration with the given [identifier]. As a side-effect, associate the
    * returned element with the identifier. Throw an [ElementMismatchException]
    * if an element corresponding to the identifier cannot be found unless
    * [required] is `false`, in which case return `null`.
    */
   Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier,
       {bool required: true}) {
     Element element = _findWithNameAndOffset(
         elements, identifier, identifier.name, identifier.offset,
         required: required);
     _expectedElements.remove(element);
     identifier.staticElement = element;
     return element;
   }
 
   /**
-   * Return the import element from the given list of [imports] whose library
-   * has the given [source]. Throw an [ElementMismatchException] if an element
-   * corresponding to the [source] cannot be found.
-   */
-  ImportElement _findImport(
-      ImportDirective node, List<ImportElement> imports, Source source) {
-    if (source == null || !_context.exists(source)) {
-      return null;
-    }
-    SimpleIdentifier prefix = node.prefix;
-    bool foundSource = false;
-    for (ImportElement element in imports) {
-      if (element.importedLibrary.source == source) {
-        foundSource = true;
-        PrefixElement prefixElement = element.prefix;
-        if (prefix == null) {
-          if (prefixElement == null) {
-            return element;
-          }
-        } else {
-          if (prefixElement != null &&
-              prefix.name == prefixElement.displayName) {
-            return element;
-          }
-        }
-      }
-    }
-    if (foundSource) {
-      if (prefix == null) {
-        _mismatch(
-            "Could not find import element for '$source' with no prefix", node);
-      }
-      _mismatch(
-          "Could not find import element for '$source' with prefix ${prefix.name}",
-          node);
-    }
-    _mismatch("Could not find import element for '$source'", node);
-    return null; // Never reached
-  }
-
-  /**
-   * Return the element in the given list of [parts] that was created for the
-   * part with the given [source]. Throw an [ElementMismatchException] if an
-   * element corresponding to the source cannot be found.
-   */
-  CompilationUnitElement _findPart(List<CompilationUnitElement> parts,
-      PartDirective directive, Source source) {
-    for (CompilationUnitElement part in parts) {
-      if (part.source == source) {
-        return part;
-      }
-    }
-    _mismatch(
-        'Could not find compilation unit element for "$source"', directive);
-    return null; // Never reached
-  }
-
-  /**
    * Return the element in the given list of [elements] that was created for the
    * declaration with the given [name] at the given [offset]. Throw an
    * [ElementMismatchException] if an element corresponding to the identifier
    * cannot be found unless [required] is `false`, in which case return `null`.
    */
   Element _findWithNameAndOffset(
       List<Element> elements, AstNode node, String name, int offset,
       {bool required: true}) {
     for (Element element in elements) {
       if (element.nameOffset == offset && element.name == name) {
@@ skipping 46 matching lines @@
           '(_enclosingParameter == null) == ${_enclosingParameter == null}');
       buffer.writeln(
           '(_enclosingExecutable == null) == ${_enclosingExecutable == null}');
       buffer.writeln('(_enclosingAlias == null) == ${_enclosingAlias == null}');
       _mismatch(buffer.toString(), parameterName);
     }
     return _findIdentifier(parameters, parameterName);
   }
 
   /**
-   * Return the value of the given string [literal], or `null` if the string is
-   * not a constant string without any string interpolation.
+   * Associate each of the annotation [nodes] with the corresponding
+   * [ElementAnnotation] in [annotations]. If there is a problem, report it
+   * against the given [parent] node.
    */
-  String _getStringValue(StringLiteral literal) {
-    if (literal is StringInterpolation) {
-      return null;
+  void _resolveAnnotations(AstNode parent, NodeList<Annotation> nodes,
+      List<ElementAnnotation> annotations) {
+    int nodeCount = nodes.length;
+    if (nodeCount != annotations.length) {

[Paul Berry, 2016/03/04 22:02:11]

Nit: in the previous version of the code, this check is done in an assert(),
meaning that it only happens in checked mode (which in practice means, it only
happens during unit tests).  Now it happens in production as well.

If we weren't planning to try to cherry-pick this CL to the stable release
candidate, I would be ok changing the behavior.  But since we are contemplating
a cherry-pick, I think we should minimize behavioral changes as much as
possible.

[Brian Wilkerson, 2016/03/07 16:20:28]

I made the change intentionally so that we would catch bugs earlier because it
makes it much easier to fix them. Given that this code should never be triggered
anyway, I think it's a positive change for users, but if you feel strongly
enough about it I guess I can temporarily back it out.

+      _mismatch(
+          'Found $nodeCount annotation nodes and ${annotations.length} element annotations',

[Paul Berry, 2016/03/04 22:02:11]

Nit: this line is more than 80 columns.  I recommend splitting it into two
strings so that the formatter can squeeze it into 80 columns, e.g.:

_mismatch(
    'Found $nodeCount annotation nodes and ${annotations.length}'
    ' element annotations',
    parent);

[Brian Wilkerson, 2016/03/07 16:20:28]

Done

+          parent);
     }
-    return literal.stringValue;
+    for (int i = 0; i < nodeCount; i++) {
+      nodes[i].elementAnnotation = annotations[i];
+    }
   }
 
   /**
-   * Throw an [ElementMismatchException] to report that the element model and
-   * the AST do not match. The [message] will have the path to the given [node]
-   * appended to it.
-   */
-  void _mismatch(String message, AstNode node) {
-    StringBuffer buffer = new StringBuffer();
-    buffer.writeln(message);
-    buffer.write('Path to root:');
-    String separator = ' ';
-    AstNode parent = node;
-    while (parent != null) {
-      buffer.write(separator);
-      buffer.write(parent.runtimeType.toString());
-      separator = ', ';
-      parent = parent.parent;
-    }
-    throw new ElementMismatchException(buffer.toString());
-  }
-
-  /**
-   * If [element] is not `null`, associate each [Annotation] in [astMetadata]
-   * with the corresponding [ElementAnnotation] in [element.metadata].
+   * If [element] is not `null`, associate each of the annotation [nodes] with
+   * the corresponding [ElementAnnotation] in [element.metadata]. If there is a
+   * problem, report it against the given [parent] node.
    *
    * If [element] is `null`, do nothing--this allows us to be robust in the
    * case where we are operating on an element model that hasn't been fully
    * built.
    */
-  void _resolveMetadata(NodeList<Annotation> astMetadata, Element element) {
+  void _resolveMetadata(
+      AstNode parent, NodeList<Annotation> nodes, Element element) {
     if (element != null) {
-      List<ElementAnnotation> elementMetadata = element.metadata;
-      assert(astMetadata.length == elementMetadata.length);
-      for (int i = 0; i < astMetadata.length; i++) {
-        astMetadata[i].elementAnnotation = elementMetadata[i];
-      }
+      _resolveAnnotations(parent, nodes, element.metadata);
     }
   }
 
   /**
    * Throw an exception if there are non-synthetic elements in the element model
    * that were not associated with an AST node.
    */
   void _validateResolution() {
     if (_expectedElements.isNotEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.write(_expectedElements.length);
       buffer.writeln(' unmatched elements found:');
       for (Element element in _expectedElements) {
         buffer.write('  ');
         buffer.writeln(element);
       }
       throw new ElementMismatchException(buffer.toString());
     }
   }
 }
 
 /**
+ * A visitor that resolves directives in an AST structure to already built
+ * elements.
+ *
+ * The resulting AST must have everything resolved that would have been resolved
+ * by a [DirectiveElementBuilder].
+ */
+class DirectiveResolver extends SimpleAstVisitor {
+  CompilationUnitElementImpl _enclosingUnit;
+
+  @override
+  void visitCompilationUnit(CompilationUnit node) {
+    _enclosingUnit = node.element;
+    for (Directive directive in node.directives) {
+      directive.accept(this);
+    }
+  }
+
+  @override
+  void visitExportDirective(ExportDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      Source source = _enclosingUnit.context.sourceFactory
+          .resolveUri(_enclosingUnit.source, uri);
+      ExportElement exportElement = _findExport(node, library.exports, source);
+      node.element = exportElement;
+    } else {
+      node.element = null;
+    }
+  }
+
+  @override
+  void visitImportDirective(ImportDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      Source source = _enclosingUnit.context.sourceFactory
+          .resolveUri(_enclosingUnit.source, uri);
+      ImportElement importElement = _findImport(node, library.imports, source);
+      node.element = importElement;
+    } else {
+      node.element = null;
+    }
+  }
+
+  @override
+  void visitLibraryDirective(LibraryDirective node) {
+    node.element = _enclosingUnit.library;
+  }
+
+  /**
+   * Return the export element from the given list of [exports] whose library
+   * has the given [source]. Throw an [ElementMismatchException] if an element
+   * corresponding to the identifier cannot be found.
+   */
+  ExportElement _findExport(
+      ExportDirective node, List<ExportElement> exports, Source source) {
+    if (source == null || !_enclosingUnit.context.exists(source)) {
+      return null;
+    }
+    for (ExportElement export in exports) {
+      if (export.exportedLibrary.source == source) {
+        return export;
+      }
+    }
+    _mismatch("Could not find export element for '$source'", node);
+    return null; // Never reached
+  }
+
+  /**
+   * Return the import element from the given list of [imports] whose library
+   * has the given [source]. Throw an [ElementMismatchException] if an element
+   * corresponding to the [source] cannot be found.
+   */
+  ImportElement _findImport(
+      ImportDirective node, List<ImportElement> imports, Source source) {
+    if (source == null || !_enclosingUnit.context.exists(source)) {
+      return null;
+    }
+    SimpleIdentifier prefix = node.prefix;
+    bool foundSource = false;
+    for (ImportElement element in imports) {
+      if (element.importedLibrary.source == source) {
+        foundSource = true;
+        PrefixElement prefixElement = element.prefix;
+        if (prefix == null) {
+          if (prefixElement == null) {
+            return element;
+          }
+        } else {
+          if (prefixElement != null &&
+              prefix.name == prefixElement.displayName) {
+            return element;
+          }
+        }
+      }
+    }
+    if (foundSource) {
+      if (prefix == null) {
+        _mismatch(
+            "Could not find import element for '$source' with no prefix", node);
+      }
+      _mismatch(
+          "Could not find import element for '$source' with prefix ${prefix.name}",
+          node);
+    }
+    _mismatch("Could not find any import element for '$source'", node);
+    return null; // Never reached
+  }
+
+  /**
+   * Return the value of the given string [literal], or `null` if the string is
+   * not a constant string without any string interpolation.
+   */
+  String _getStringValue(StringLiteral literal) {
+    if (literal is StringInterpolation) {
+      return null;
+    }
+    return literal.stringValue;
+  }
+}
+
+/**
  * 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;
 
   List<ClassElement> _enums;
 
@@ skipping 357 matching lines @@
 }
 
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  */
 class EnclosedScope extends Scope {
   /**
    * The scope in which this scope is lexically enclosed.
    */
+  @override
   final Scope enclosingScope;
 
   /**
    * A table mapping names that will be defined in this scope, but right now are not initialized.
    * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
   HashMap<String, Element> _hiddenElements = new HashMap<String, Element>();
 
   /**
@@ skipping 2771 matching lines @@
  */
 class LibraryImportScope extends Scope {
   /**
    * The element representing the library in which this scope is enclosed.
    */
   final LibraryElement _definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
+  @override
   final AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces;
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
@@ skipping 1177 matching lines @@
 
   /**
    * The type system in use during resolution.
    */
   TypeSystem typeSystem;
 
   /**
    * The class element representing the class containing the current node,
    * or `null` if the current node is not contained in a class.
    */
+  @override
   ClassElement enclosingClass = null;
 
   /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    */
   ClassDeclaration _enclosingClassDeclaration = null;
 
   /**
    * The function type alias representing the function type containing the current node, or
@@ skipping 5684 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }