Fixes to associating existing elements with an AST

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/token.dart';
@@ skipping 186 matching lines @@
         }
       }
     }
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     // Remove previous element. (It will remain null if the target is missing.)
     node.element = null;
-
-    String uriContent = node.uriContent;
-    if (DartUriResolver.isDartExtUri(uriContent)) {
-      libraryElement.hasExtUri = true;
-    }
     Source importedSource = node.source;
     if (importedSource != null && context.exists(importedSource)) {
       // The imported source will be null if the URI in the import
       // directive was invalid.
       LibraryElement importedLibrary = importLibraryMap[importedSource];
       if (importedLibrary != null) {
         if (importedLibrary.isDartCore) {
           explicitlyImportsCore = true;
         }
         ImportElementImpl importElement = new ImportElementImpl(node.offset);
         importElement.metadata = _getElementAnnotations(node.metadata);
         StringLiteral uriLiteral = node.uri;
         if (uriLiteral != null) {
           importElement.uriOffset = uriLiteral.offset;
           importElement.uriEnd = uriLiteral.end;
         }
-        importElement.uri = uriContent;
+        importElement.uri = node.uriContent;
         importElement.deferred = node.deferredKeyword != null;
         importElement.combinators = _buildCombinators(node);
         importElement.importedLibrary = importedLibrary;
         setElementDocumentationComment(importElement, node);
         SimpleIdentifier prefixNode = node.prefix;
         if (prefixNode != null) {
           importElement.prefixOffset = prefixNode.offset;
           String prefixName = prefixNode.name;
           PrefixElementImpl prefix = nameToPrefixMap[prefixName];
           if (prefix == null) {
@@ skipping 66 matching lines @@
 
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  */
 class ElementBuilder extends RecursiveAstVisitor<Object> {
   /**
    * The compilation unit element into which the elements being built will be
    * stored.
    */
-  final CompilationUnitElement compilationUnitElement;
+  final CompilationUnitElementImpl compilationUnitElement;
 
   /**
    * The element holder associated with the element that is currently being built.
    */
   ElementHolder _currentHolder;
 
   /**
    * A flag indicating whether a variable declaration is within the body of a method or function.
    */
   bool _inFunction = false;
 
   /**
    * A collection holding the elements defined in a class that need to have
    * their function type fixed to take into account type parameters of the
    * enclosing class, or `null` if we are not currently processing nodes within
    * a class.
    */
   List<ExecutableElementImpl> _functionTypesToFix = null;
 
   /**
    * A table mapping field names to field elements for the fields defined in the current class, or
    * `null` if we are not in the scope of a class.
    */
   HashMap<String, FieldElement> _fieldMap;
 
   /**
-   * Initialize a newly created element builder to build the elements for a compilation unit.
-   *
-   * @param initialHolder the element holder associated with the compilation unit being built
+   * Initialize a newly created element builder to build the elements for a
+   * compilation unit. The [initialHolder] is the element holder to which the
+   * children of the visited compilation unit node will be added.
    */
   ElementBuilder(ElementHolder initialHolder, this.compilationUnitElement) {
     _currentHolder = initialHolder;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     // Although it isn't valid to do so because closures are not constant
     // expressions, it's possible for one of the arguments to the constructor to
     // contain a closure. Wrapping the processing of the annotation this way
@@ skipping 122 matching lines @@
     setElementDocumentationComment(element, node);
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     if (compilationUnitElement is ElementImpl) {
-      _setCodeRange(compilationUnitElement as ElementImpl, node);
+      _setCodeRange(compilationUnitElement, node);
     }
     return super.visitCompilationUnit(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
@@ skipping 128 matching lines @@
     // 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;
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
-    _createElementAnnotations(node.metadata);
+    List<ElementAnnotation> annotations =
+        _createElementAnnotations(node.metadata);
+    compilationUnitElement.setAnnotations(node.offset, annotations);
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       FieldElement field =
           _fieldMap == null ? null : _fieldMap[parameterName.name];
       FieldFormalParameterElementImpl parameter =
@@ skipping 241 matching lines @@
     ParameterElementImpl element = node.element;
     element.metadata = _createElementAnnotations(node.metadata);
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
-    _createElementAnnotations(node.metadata);
+    List<ElementAnnotation> annotations =
+        _createElementAnnotations(node.metadata);
+    compilationUnitElement.setAnnotations(node.offset, annotations);
     return super.visitImportDirective(node);
   }
 
   @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.forNode(labelName, onSwitchStatement, false);
       _setCodeRange(element, node);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
-    _createElementAnnotations(node.metadata);
+    List<ElementAnnotation> annotations =
+        _createElementAnnotations(node.metadata);
+    compilationUnitElement.setAnnotations(node.offset, annotations);
     return super.visitLibraryDirective(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     try {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
@@ skipping 142 matching lines @@
             buffer.toString(),
             new CaughtException(
                 new AnalysisException(buffer.toString()), null));
       }
     }
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
-    _createElementAnnotations(node.metadata);
+    List<ElementAnnotation> annotations =
+        _createElementAnnotations(node.metadata);
+    compilationUnitElement.setAnnotations(node.offset, annotations);
     return super.visitPartDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       _setCodeRange(parameter, node);
@@ skipping 362 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();
   }
 }