Fixes to associating existing elements with an AST

pkg/analyzer/lib/src/dart/element/element.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.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 910 matching lines @@
   /**
    * The source of the library containing this compilation unit.
    *
    * This is the same as the source of the containing [LibraryElement],
    * except that it does not require the containing [LibraryElement] to be
    * computed.
    */
   Source librarySource;
 
   /**
+   * A table mapping the offset of a directive to the annotations associated
+   * with that directive, or `null` if none of the annotations in the
+   * compilation unit have annotations.
+   */
+  Map<int, List<ElementAnnotation>> annotationMap = null;
+
+  /**
    * A list containing all of the top-level accessors (getters and setters)
    * contained in this compilation unit.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
 
   /**
    * A list containing all of the enums contained in this compilation unit.
    */
   List<ClassElement> _enums = ClassElement.EMPTY_LIST;
 
@@ skipping 155 matching lines @@
     if (source == null) {
       buffer.write("{compilation unit}");
     } else {
       buffer.write(source.fullName);
     }
   }
 
   @override
   CompilationUnit computeNode() => unit;
 
+  /**
+   * Return the annotations associated with the directive at the given [offset],
+   * or an empty list if the directive has no annotations or if there is no
+   * directive at the given offset.
+   */
+  List<ElementAnnotation> getAnnotations(int offset) {
+    if (annotationMap == null) {
+      return ElementAnnotation.EMPTY_LIST;
+    }
+    return annotationMap[offset] ?? ElementAnnotation.EMPTY_LIST;
+  }
+
   @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have
     // thrown a CCE if any of the elements in the arrays were not of the
     // expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
@@ skipping 58 matching lines @@
 
   /**
    * Replace the given [from] top-level variable with [to] in this compilation unit.
    */
   void replaceTopLevelVariable(
       TopLevelVariableElement from, TopLevelVariableElement to) {
     int index = _variables.indexOf(from);
     _variables[index] = to;
   }
 
+  /**
+   * Set the annotations associated with the directive at the given [offset] to
+   * the given list of [annotations].
+   */
+  void setAnnotations(int offset, List<ElementAnnotation> annotations) {
+    if (annotationMap == null) {

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

Nit: this seems like a premature optimization (there are not very compilation
units and an empty hash map is cheap to create).  I'd recommend making
annotationMap final and initializing it at the declaration site.

(It's possible that that might even be a speed improvement, since making the
annotationMap final and initializing it at the declaration site guarantees to
the VM that it will never be null, so it may be able to eliminate some null
checks).

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

I have almost 3000 CompilationUnitElements in my environment, and I don't have
nearly as much code loaded as some of our users. But you might be right. I'm
leaving it in for now, but we can back it out later if it proves to be
unnecessary.

+      annotationMap = new HashMap<int, List<ElementAnnotation>>();

[scheglov, 2016/03/04 21:49:30]

annotationMap ??= new HashMap<int, List<ElementAnnotation>>(); would be a bit
more compact.

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

Done

+    }
+    annotationMap[offset] = annotations;
+  }
+
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_enums, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
@@ skipping 73 matching lines @@
 }
 
 /**
  * A concrete implementation of a [ConstructorElement].
  */
 class ConstructorElementImpl extends ExecutableElementImpl
     implements ConstructorElement {
   /**
    * The constructor to which this constructor is redirecting.
    */
+  @override

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

Normally I am ok with rolling this sort of clean-up into an unrelated CL like
this, but since we are likely to want to try cherry-picking this CL over to the
stable release candidate, I think we should keep it as small as possible to
reduce the risk of merge conflicts.

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

Not sure it didn't take more time to remove them, but it's done.

   ConstructorElement redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant
    * instance creation expressions).
    */
   List<ConstructorInitializer> constantInitializers;
 
   /**
    * The offset of the `.` before this constructor name or `null` if not named.
    */
+  @override
   int periodOffset;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
+  @override
   int nameEnd;
 
   /**
    * True if this constructor has been found by constant evaluation to be free
    * of redirect cycles, and is thus safe to evaluate.
    */
   bool isCycleFree = false;
 
   /**
    * Initialize a newly created constructor element to have the given [name] and
@@ skipping 283 matching lines @@
   /**
    * The name of the top-level variable used to mark a class as implementing a
    * proxy object.
    */
   static String PROXY_VARIABLE_NAME = "proxy";
 
   /**
    * The element representing the field, variable, or constructor being used as
    * an annotation.
    */
+  @override
   Element element;
 
   /**
    * The compilation unit in which this annotation appears.
    */
   final CompilationUnitElementImpl compilationUnit;
 
   /**
    * The AST of the annotation itself, cloned from the resolved AST for the
    * source code.
@@ skipping 65 matching lines @@
  * A base class for concrete implementations of an [Element].
  */
 abstract class ElementImpl implements Element {
   /**
    * An Unicode right arrow.
    */
   static final String RIGHT_ARROW = " \u2192 ";
 
   static int _NEXT_ID = 0;
 
+  @override
   final int id = _NEXT_ID++;
 
   /**
    * The enclosing element of this element, or `null` if this element is at the
    * root of the element structure.
    */
   ElementImpl _enclosingElement;
 
   /**
    * The name of this element.
    */
   String _name;
 
   /**
    * The offset of the name of this element in the file that contains the
    * declaration of this element.
    */
   int _nameOffset = 0;
 
   /**
    * A bit-encoded form of the modifiers associated with this element.
    */
   int _modifiers = 0;
 
   /**
    * A list containing all of the metadata associated with this element.
    */
+  @override
   List<ElementAnnotation> metadata = ElementAnnotation.EMPTY_LIST;
 
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode;
 
   /**
    * A cached copy of the calculated location for this element.
    */
@@ skipping 577 matching lines @@
 
   /**
    * A list containing all of the type parameters defined for this executable
    * element.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this executable element.
    */
+  @override
   DartType returnType;
 
   /**
    * The type of function defined by this executable element.
    */
+  @override
   FunctionType type;
 
   /**
    * Initialize a newly created executable element to have the given [name] and
    * [offset].
    */
   ExecutableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created executable element to have the given [name].
@@ skipping 207 matching lines @@
 }
 
 /**
  * A concrete implementation of an [ExportElement].
  */
 class ExportElementImpl extends UriReferencedElementImpl
     implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
+  @override
   LibraryElement exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the
    * order in which they were specified.
    */
+  @override
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST;
 
   /**
    * Initialize a newly created export element at the given [offset].
    */
   ExportElementImpl(int offset) : super(null, offset);
 
   @override
   String get identifier => exportedLibrary.name;
 
@@ skipping 58 matching lines @@
 
 /**
  * A [ParameterElementImpl] that has the additional information of the
  * [FieldElement] associated with the parameter.
  */
 class FieldFormalParameterElementImpl extends ParameterElementImpl
     implements FieldFormalParameterElement {
   /**
    * The field associated with this field formal parameter.
    */
+  @override
   FieldElement field;
 
   /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
    */
   FieldFormalParameterElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
 
   /**
@@ skipping 134 matching lines @@
 class FunctionTypeAliasElementImpl extends ElementImpl
     implements FunctionTypeAliasElement {
   /**
    * A list containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this type alias.
    */
+  @override
   DartType returnType;
 
   /**
    * The type of function defined by this type alias.
    */
+  @override
   FunctionType type;
 
   /**
    * A list containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
@@ skipping 110 matching lines @@
 }
 
 /**
  * A concrete implementation of a [HideElementCombinator].
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
    * The names that are not to be made visible in the importing library even if
    * they are defined in the imported library.
    */
+  @override
   List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         buffer.write(", ");
       }
       buffer.write(hiddenNames[i]);
     }
     return buffer.toString();
   }
 }
 
 /**
  * A concrete implementation of an [ImportElement].
  */
 class ImportElementImpl extends UriReferencedElementImpl
     implements ImportElement {
   /**
    * The offset of the prefix of this import in the file that contains the this
    * import directive, or `-1` if this import is synthetic.
    */
+  @override
   int prefixOffset = 0;
 
   /**
    * The library that is imported into this library by this import directive.
    */
+  @override
   LibraryElement importedLibrary;
 
   /**
    * The combinators that were specified as part of the import directive in the
    * order in which they were specified.
    */
+  @override
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST;
 
   /**
    * The prefix that was specified as part of the import directive, or `null` if
    * there was no prefix specified.
    */
+  @override
   PrefixElement prefix;
 
   /**
    * Initialize a newly created import element at the given [offset].
    * The offset may be `-1` if the import is synthetic.
    */
   ImportElementImpl(int offset) : super(null, offset);
 
   /**
    * Set whether this import is for a deferred library.
@@ skipping 87 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 }
 
 /**
  * A concrete implementation of a [LibraryElement].
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * The analysis context in which this library is defined.
    */
+  @override
   final AnalysisContext context;
 
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
 
   /**
    * The entry point for this library, or `null` if this library does not have
    * an entry point.
    */
+  @override
   FunctionElement entryPoint;
 
   /**
    * A list containing specifications of all of the imports defined in this
    * library.
    */
   List<ImportElement> _imports = ImportElement.EMPTY_LIST;
 
   /**
    * A list containing specifications of all of the exports defined in this
@@ skipping 850 matching lines @@
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * A concrete implementation of a [MultiplyDefinedElement].
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
    * The unique integer identifier of this element.
    */
+  @override
   final int id = ElementImpl._NEXT_ID++;
 
   /**
    * The analysis context in which the multiply defined elements are defined.
    */
+  @override
   final AnalysisContext context;
 
   /**
    * The name of the conflicting elements.
    */
   String _name;
 
   /**
    * A list containing all of the elements that conflict.
    */
+  @override
   final List<Element> conflictingElements;
 
   /**
    * Initialize a newly created element in the given [context] to represent a
    * list of [conflictingElements].
    */
   MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
     _name = conflictingElements[0].name;
   }
 
@@ skipping 227 matching lines @@
   /**
    * A list containing all of the type parameters defined for this parameter
    * element. There will only be parameters if this parameter is a function
    * typed parameter.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * The kind of this parameter.
    */
+  @override
   ParameterKind parameterKind;
 
   /**
    * The Dart code of the default value.
    */
   String _defaultValueCode;
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
@@ skipping 199 matching lines @@
 }
 
 /**
  * A concrete implementation of a [PropertyAccessorElement].
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl
     implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
    */
+  @override
   PropertyInducingElement variable;
 
   /**
    * Initialize a newly created property accessor element to have the given
    * [name] and [offset].
    */
   PropertyAccessorElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created property accessor element to have the given
@@ skipping 122 matching lines @@
 }
 
 /**
  * A concrete implementation of a [PropertyInducingElement].
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl
     implements PropertyInducingElement {
   /**
    * The getter associated with this element.
    */
+  @override
   PropertyAccessorElement getter;
 
   /**
    * The setter associated with this element, or `null` if the element is
    * effectively `final` and therefore does not have a setter associated with
    * it.
    */
+  @override
   PropertyAccessorElement setter;
 
   /**
    * The propagated type of this variable, or `null` if type propagation has not
    * been performed.
    */
+  @override
   DartType propagatedType;
 
   /**
    * Initialize a newly created synthetic element to have the given [name] and
    * [offset].
    */
   PropertyInducingElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
 }
 
 /**
  * A concrete implementation of a [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
    * The names that are to be made visible in the importing library if they are
    * defined in the imported library.
    */
+  @override
   List<String> shownNames = StringUtilities.EMPTY_ARRAY;
 
   /**
    * The offset of the character immediately following the last character of
    * this node.
    */
+  @override
   int end = -1;
 
   /**
    * The offset of the 'show' keyword of this element.
    */
+  @override
   int offset = 0;
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         buffer.write(", ");
@@ skipping 36 matching lines @@
 }
 
 /**
  * A concrete implementation of a [TypeParameterElement].
  */
 class TypeParameterElementImpl extends ElementImpl
     implements TypeParameterElement {
   /**
    * The type defined by this type parameter.
    */
+  @override
   TypeParameterType type;
 
   /**
    * The type representing the bound associated with this parameter, or `null`
    * if this parameter does not have an explicit bound.
    */
+  @override
   DartType bound;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
   TypeParameterElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created type parameter element to have the given [name].
@@ skipping 25 matching lines @@
 }
 
 /**
  * A concrete implementation of a [UriReferencedElement].
  */
 abstract class UriReferencedElementImpl extends ElementImpl
     implements UriReferencedElement {
   /**
    * The offset of the URI in the file, may be `-1` if synthetic.
    */
+  @override
   int uriOffset = -1;
 
   /**
    * The offset of the character immediately following the last character of
    * this node's URI, may be `-1` if synthetic.
    */
+  @override
   int uriEnd = -1;
 
   /**
    * The URI that is specified by this directive.
    */
+  @override
   String uri;
 
   /**
    * Initialize a newly created import element to have the given [name] and
    * [offset]. The offset may be `-1` if the element is synthetic.
    */
   UriReferencedElementImpl(String name, int offset) : super(name, offset);
 }
 
 /**
  * A concrete implementation of a [VariableElement].
  */
 abstract class VariableElementImpl extends ElementImpl
     implements VariableElement {
   /**
    * The declared type of this variable.
    */
+  @override
   DartType type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if
    * this variable does not have an initializer.
    */
   FunctionElement _initializer;
 
   /**
    * Initialize a newly created variable element to have the given [name] and
@@ skipping 114 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }