Rename EMPTY_ARRAY to EMPTY_LIST in element model

pkg/analyzer/lib/src/generated/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 92 matching lines @@
   @override
   BottomTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }
 
 /**
  * An element that represents a class.
  */
 abstract class ClassElement implements Element {
   /**
+   * An empty list of class elements.
+   */
+  static const List<ClassElement> EMPTY_LIST = const <ClassElement>[];
+
+  /**
    * Return a list containing all of the accessors (getters and setters)
    * declared in this class.
    */
   List<PropertyAccessorElement> get accessors;
 
   /**
    * Return a list containing all the supertypes defined for this class and its
    * supertypes. This includes superclasses, mixins and interfaces.
    */
   List<InterfaceType> get allSupertypes;
@@ skipping 330 matching lines @@
       String setterName, LibraryElement library);
 }
 
 /**
  * A concrete implementation of a [ClassElement].
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An empty list of class elements.
    */
+  @deprecated // Use ClassElement.EMPTY_LIST
   static const List<ClassElement> EMPTY_ARRAY = const <ClassElement>[];
 
   /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
-  List<PropertyAccessorElement> _accessors =
-      PropertyAccessorElementImpl.EMPTY_ARRAY;
+  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
 
   /**
    * A list containing all of the constructors contained in this class.
    */
-  List<ConstructorElement> _constructors = ConstructorElementImpl.EMPTY_ARRAY;
+  List<ConstructorElement> _constructors = ConstructorElement.EMPTY_LIST;
 
   /**
    * A list containing all of the fields contained in this class.
    */
-  List<FieldElement> _fields = FieldElementImpl.EMPTY_ARRAY;
+  List<FieldElement> _fields = FieldElement.EMPTY_LIST;
 
   /**
    * A list containing all of the mixins that are applied to the class being
    * extended in order to derive the superclass of this class.
    */
-  List<InterfaceType> mixins = InterfaceType.EMPTY_ARRAY;
+  List<InterfaceType> mixins = InterfaceType.EMPTY_LIST;
 
   /**
    * A list containing all of the interfaces that are implemented by this class.
    */
-  List<InterfaceType> interfaces = InterfaceType.EMPTY_ARRAY;
+  List<InterfaceType> interfaces = InterfaceType.EMPTY_LIST;
 
   /**
    * A list containing all of the methods contained in this class.
    */
-  List<MethodElement> _methods = MethodElementImpl.EMPTY_ARRAY;
+  List<MethodElement> _methods = MethodElement.EMPTY_LIST;
 
   /**
    * The superclass of the class, or `null` if the class does not have an
    * explicit superclass.
    */
   InterfaceType supertype;
 
   /**
    * The type defined by the class.
    */
   InterfaceType type;
 
   /**
    * A list containing all of the type parameters defined for this class.
    */
-  List<TypeParameterElement> _typeParameters =
-      TypeParameterElementImpl.EMPTY_ARRAY;
+  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * The [SourceRange] of the `with` clause, `null` if there is no one.
    */
   SourceRange withClauseRange;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
@@ skipping 625 matching lines @@
    * an entire library or class.
    */
   bool get isStatic;
 }
 
 /**
  * An element representing a compilation unit.
  */
 abstract class CompilationUnitElement implements Element, UriReferencedElement {
   /**
+   * An empty list of compilation unit elements.
+   */
+  static const List<CompilationUnitElement> EMPTY_LIST =
+      const <CompilationUnitElement>[];
+
+  /**
    * Return a list containing all of the top-level accessors (getters and
    * setters) contained in this compilation unit.
    */
   List<PropertyAccessorElement> get accessors;
 
   /**
    * Return the library in which this compilation unit is defined.
    */
   @override
   LibraryElement get enclosingElement;
@@ skipping 64 matching lines @@
 }
 
 /**
  * A concrete implementation of a [CompilationUnitElement].
  */
 class CompilationUnitElementImpl extends UriReferencedElementImpl
     implements CompilationUnitElement {
   /**
    * An empty list of compilation unit elements.
    */
+  @deprecated // Use CompilationUnitElement.EMPTY_LIST
   static const List<CompilationUnitElement> EMPTY_ARRAY =
       const <CompilationUnitElement>[];
 
   /**
    * The source that corresponds to this compilation unit.
    */
   Source source;
 
   /**
    * A list containing all of the top-level accessors (getters and setters)
    * contained in this compilation unit.
    */
-  List<PropertyAccessorElement> _accessors =
-      PropertyAccessorElementImpl.EMPTY_ARRAY;
+  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
 
   /**
    * A list containing all of the enums contained in this compilation unit.
    */
-  List<ClassElement> _enums = ClassElementImpl.EMPTY_ARRAY;
+  List<ClassElement> _enums = ClassElement.EMPTY_LIST;
 
   /**
    * A list containing all of the top-level functions contained in this
    * compilation unit.
    */
-  List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
+  List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
 
   /**
    * A list containing all of the function type aliases contained in this
    * compilation unit.
    */
   List<FunctionTypeAliasElement> _typeAliases =
-      FunctionTypeAliasElementImpl.EMPTY_ARRAY;
+      FunctionTypeAliasElement.EMPTY_LIST;
 
   /**
    * A list containing all of the types contained in this compilation unit.
    */
-  List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
+  List<ClassElement> _types = ClassElement.EMPTY_LIST;
 
   /**
    * A list containing all of the variables contained in this compilation unit.
    */
-  List<TopLevelVariableElement> _variables =
-      TopLevelVariableElementImpl.EMPTY_ARRAY;
+  List<TopLevelVariableElement> _variables = TopLevelVariableElement.EMPTY_LIST;
 
   /**
    * A map from offsets to elements of this unit at these offsets.
    */
   final Map<int, Element> _offsetToElementMap = new HashMap<int, Element>();
 
   /**
    * Initialize a newly created compilation unit element to have the given
    * [name].
    */
@@ skipping 280 matching lines @@
   }
 }
 
 /**
  * An element representing a constructor or a factory method defined within a
  * class.
  */
 abstract class ConstructorElement
     implements ClassMemberElement, ExecutableElement {
   /**
+   * An empty list of constructor elements.
+   */
+  static const List<ConstructorElement> EMPTY_LIST =
+      const <ConstructorElement>[];
+
+  /**
    * Return `true` if this constructor is a const constructor.
    */
   bool get isConst;
 
   /**
    * Return `true` if this constructor can be used as a default constructor -
    * unnamed and has no required parameters.
    */
   bool get isDefaultConstructor;
 
@@ skipping 33 matching lines @@
 }
 
 /**
  * A concrete implementation of a [ConstructorElement].
  */
 class ConstructorElementImpl extends ExecutableElementImpl
     implements ConstructorElement {
   /**
    * An empty list of constructor elements.
    */
+  @deprecated // Use ConstructorElement.EMPTY_LIST
   static const List<ConstructorElement> EMPTY_ARRAY =
       const <ConstructorElement>[];
 
   /**
    * The constructor to which this constructor is redirecting.
    */
   ConstructorElement redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant
@@ skipping 260 matching lines @@
    * initializers.
    */
   Expression constantInitializer;
 }
 
 /**
  * The type associated with elements in the element model.
  */
 abstract class DartType {
   /**
+   * An empty list of types.
+   */
+  static const List<DartType> EMPTY_LIST = const <DartType>[];
+
+  /**
    * Return the name of this type as it should appear when presented to users in
    * contexts such as error messages.
    */
   String get displayName;
 
   /**
    * Return the element representing the declaration of this type, or `null` if
    * the type has not, or cannot, be associated with an element. The former case
    * will occur if the element model is not yet complete; the latter case will
    * occur if this object represents an undefined type.
@@ skipping 451 matching lines @@
    * is no guarantee of the order in which the children will be visited.
    */
   void visitChildren(ElementVisitor visitor);
 }
 
 /**
  * A single annotation associated with an element.
  */
 abstract class ElementAnnotation {
   /**
+   * An empty list of annotations.
+   */
+  static const List<ElementAnnotation> EMPTY_LIST = const <ElementAnnotation>[];
+
+  /**
    * Return the element representing the field, variable, or const constructor
    * being used as an annotation.
    */
   Element get element;
 
   /**
    * Return `true` if this annotation marks the associated element as being
    * deprecated.
    */
   bool get isDeprecated;
@@ skipping 11 matching lines @@
   bool get isProxy;
 }
 
 /**
  * A concrete implementation of an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * An empty list of annotations.
    */
+  @deprecated // Use ElementAnnotation.EMPTY_LIST
   static const List<ElementAnnotationImpl> EMPTY_ARRAY =
       const <ElementAnnotationImpl>[];
 
   /**
    * The name of the class used to mark an element as being deprecated.
    */
   static String _DEPRECATED_CLASS_NAME = "Deprecated";
 
   /**
    * The name of the top-level variable used to mark an element as being
@@ skipping 111 matching lines @@
   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.
    */
-  List<ElementAnnotation> metadata = ElementAnnotationImpl.EMPTY_ARRAY;
+  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.
    */
   ElementLocation _cachedLocation;
@@ skipping 733 matching lines @@
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 
 /**
  * An element representing an executable object, including functions, methods,
  * constructors, getters, and setters.
  */
 abstract class ExecutableElement implements Element {
   /**
+   * An empty list of executable elements.
+   */
+  static const List<ExecutableElement> EMPTY_LIST = const <ExecutableElement>[];
+
+  /**
    * Return a list containing all of the functions defined within this
    * executable element.
    */
   List<FunctionElement> get functions;
 
   /**
    * Return `true` if this executable element is abstract.
    * Executable elements are abstract if they are not external and have no body.
    */
   bool get isAbstract;
@@ skipping 60 matching lines @@
 }
 
 /**
  * A base class for concrete implementations of an [ExecutableElement].
  */
 abstract class ExecutableElementImpl extends ElementImpl
     implements ExecutableElement {
   /**
    * An empty list of executable elements.
    */
+  @deprecated // Use ExecutableElement.EMPTY_LIST
   static const List<ExecutableElement> EMPTY_ARRAY =
       const <ExecutableElement>[];
 
   /**
    * A list containing all of the functions defined within this executable
    * element.
    */
-  List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
+  List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
 
   /**
    * A list containing all of the labels defined within this executable element.
    */
-  List<LabelElement> _labels = LabelElementImpl.EMPTY_ARRAY;
+  List<LabelElement> _labels = LabelElement.EMPTY_LIST;
 
   /**
    * A list containing all of the local variables defined within this executable
    * element.
    */
-  List<LocalVariableElement> _localVariables =
-      LocalVariableElementImpl.EMPTY_ARRAY;
+  List<LocalVariableElement> _localVariables = LocalVariableElement.EMPTY_LIST;
 
   /**
    * A list containing all of the parameters defined by this executable element.
    */
-  List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
+  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this executable element.
    */
   DartType returnType;
 
   /**
    * The type of function defined by this executable element.
    */
   FunctionType type;
@@ skipping 260 matching lines @@
   }
 }
 
 /**
  * An export directive within a library.
  */
 abstract class ExportElement implements Element, UriReferencedElement {
   /**
    * An empty list of export elements.
    */
+  @deprecated // Use ExportElement.EMPTY_LIST
   static const List<ExportElement> EMPTY_ARRAY = const <ExportElement>[];
 
   /**
+   * An empty list of export elements.
+   */
+  static const List<ExportElement> EMPTY_LIST = const <ExportElement>[];
+
+  /**
    * Return a list containing the combinators that were specified as part of the
    * export directive in the order in which they were specified.
    */
   List<NamespaceCombinator> get combinators;
 
   /**
    * Return the library that is exported from this library by this export
    * directive.
    */
   LibraryElement get exportedLibrary;
 }
 
 /**
  * A concrete implementation of an [ExportElement].
  */
 class ExportElementImpl extends UriReferencedElementImpl
     implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
   LibraryElement exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the
    * order in which they were specified.
    */
-  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
+  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;
 
   @override
@@ skipping 44 matching lines @@
   accept(ElementVisitor visitor) =>
       visitor.visitExternalHtmlScriptElement(this);
 }
 
 /**
  * A field defined within a type.
  */
 abstract class FieldElement
     implements ClassMemberElement, PropertyInducingElement {
   /**
+   * An empty list of field elements.
+   */
+  static const List<FieldElement> EMPTY_LIST = const <FieldElement>[];
+
+  /**
    * Return {@code true} if this element is an enum constant.
    */
   bool get isEnumConstant;
 
   /**
    * Return the resolved [VariableDeclaration] or [EnumConstantDeclaration]
    * node that declares this [FieldElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   AstNode get node;
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
     with PotentiallyConstVariableElement implements FieldElement {
   /**
    * An empty list of field elements.
    */
+  @deprecated // Use FieldElement.EMPTY_LIST
   static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created synthetic field element to have the given [name]
    * at the given [offset].
    */
   FieldElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created field element to have the given [name].
@@ skipping 193 matching lines @@
   }
 }
 
 /**
  * A (non-method) function. This can be either a top-level function, a local
  * function, a closure, or the initialization expression for a field or
  * variable.
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
+   * An empty list of function elements.
+   */
+  static const List<FunctionElement> EMPTY_LIST = const <FunctionElement>[];
+
+  /**
    * The name of the method that can be implemented by a class to allow its
    * instances to be invoked as if they were a function.
    */
   static final String CALL_METHOD_NAME = "call";
 
   /**
    * The name of the synthetic function defined for libraries that are deferred.
    */
   static final String LOAD_LIBRARY_NAME = "loadLibrary";
 
@@ skipping 25 matching lines @@
 }
 
 /**
  * A concrete implementation of a [FunctionElement].
  */
 class FunctionElementImpl extends ExecutableElementImpl
     implements FunctionElement {
   /**
    * An empty list of function elements.
    */
+  @deprecated // Use FunctionElement.EMPTY_LIST
   static const List<FunctionElement> EMPTY_ARRAY = const <FunctionElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element
    * does not have a visible range.
@@ skipping 194 matching lines @@
    * `substitute(argumentTypes, getTypeArguments())`.
    */
   FunctionType substitute3(List<DartType> argumentTypes);
 }
 
 /**
  * A function type alias (`typedef`).
  */
 abstract class FunctionTypeAliasElement implements Element {
   /**
+   * An empty array of type alias elements.
+   */
+  static List<FunctionTypeAliasElement> EMPTY_LIST =
+      new List<FunctionTypeAliasElement>(0);
+
+  /**
    * Return the compilation unit in which this type alias is defined.
    */
   @override
   CompilationUnitElement get enclosingElement;
 
   /**
    * Return the resolved function type alias node that declares this element.
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
@@ skipping 23 matching lines @@
 }
 
 /**
  * A concrete implementation of a [FunctionTypeAliasElement].
  */
 class FunctionTypeAliasElementImpl extends ElementImpl
     implements FunctionTypeAliasElement {
   /**
    * An empty array of type alias elements.
    */
+  @deprecated // Use FunctionTypeAliasElement.EMPTY_LIST
   static List<FunctionTypeAliasElement> EMPTY_ARRAY =
       new List<FunctionTypeAliasElement>(0);
 
   /**
    * A list containing all of the parameters defined by this type alias.
    */
-  List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
+  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this type alias.
    */
   DartType returnType;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType type;
 
   /**
    * A list containing all of the type parameters defined for this type.
    */
-  List<TypeParameterElement> _typeParameters =
-      TypeParameterElementImpl.EMPTY_ARRAY;
+  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
    * [name] the name of this element
    * [nameOffset] the offset of the name of this element in the file that
    *    contains the declaration of this element
    */
   FunctionTypeAliasElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
@@ skipping 121 matching lines @@
   }
 }
 
 /**
  * The type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
    * A list containing the actual types of the type arguments.
    */
-  List<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
+  List<DartType> typeArguments = DartType.EMPTY_LIST;
 
   /**
    * Initialize a newly created function type to be declared by the given
    * [element].
    */
   FunctionTypeImpl.con1(ExecutableElement element) : super(element, null);
 
   /**
    * Initialize a newly created function type to be declared by the given
    * [element].
@@ skipping 119 matching lines @@
         namedParameterTypes[parameter.name] = type;
       }
     }
     return namedParameterTypes;
   }
 
   @override
   List<DartType> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
-      return TypeImpl.EMPTY_ARRAY;
+      return DartType.EMPTY_LIST;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.REQUIRED) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
           type = type.substitute2(typeArguments, typeParameters);
         }
         types.add(type);
       }
     }
     return types;
   }
 
   @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
-      return TypeImpl.EMPTY_ARRAY;
+      return DartType.EMPTY_LIST;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.POSITIONAL) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
           type = type.substitute2(typeArguments, typeParameters);
@@ skipping 43 matching lines @@
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return element.typeParameters;
     }
     ClassElement definingClass =
         element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       return definingClass.typeParameters;
     }
-    return TypeParameterElementImpl.EMPTY_ARRAY;
+    return TypeParameterElement.EMPTY_LIST;
   }
 
   @override
   bool operator ==(Object object) =>
       internalEquals(object, new HashSet<ElementPair>());
 
   @override
   void appendTo(StringBuffer buffer, Set<DartType> visitedTypes) {
     if (!visitedTypes.add(this)) {
       buffer.write(name == null ? '...' : name);
@@ skipping 655 matching lines @@
     }
     return buffer.toString();
   }
 }
 
 /**
  * An HTML file.
  */
 abstract class HtmlElement implements Element {
   /**
+   * An empty list of HTML file elements.
+   */
+  static const List<HtmlElement> EMPTY_LIST = const <HtmlElement>[];
+
+  /**
    * Return a list containing all of the script elements contained in the HTML
    * file. This includes scripts with libraries that are defined by the content
    * of a script tag as well as libraries that are referenced in the `source`
    * attribute of a script tag.
    */
   List<HtmlScriptElement> get scripts;
 }
 
 /**
  * A concrete implementation of an [HtmlElement].
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty list of HTML file elements.
    */
+  @deprecated // Use HtmlElement.EMPTY_LIST
   static const List<HtmlElement> EMPTY_ARRAY = const <HtmlElement>[];
 
   /**
    * The analysis context in which this library is defined.
    */
   final AnalysisContext context;
 
   /**
    * The scripts contained in or referenced from script tags in the HTML file.
    */
-  List<HtmlScriptElement> _scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
+  List<HtmlScriptElement> _scripts = HtmlScriptElement.EMPTY_LIST;
 
   /**
    * The source that corresponds to this HTML file.
    */
   Source source;
 
   /**
    * Initialize a newly created HTML element in the given [context] to have the
    * given [name].
    */
   HtmlElementImpl(this.context, String name) : super(name, -1);
 
   @override
   int get hashCode => source.hashCode;
 
   @override
   String get identifier => source.encoding;
 
   @override
   ElementKind get kind => ElementKind.HTML;
 
   @override
   List<HtmlScriptElement> get scripts => _scripts;
 
   /**
    * Set the scripts contained in the HTML file to the given [scripts].
    */
   void set scripts(List<HtmlScriptElement> scripts) {
     if (scripts.length == 0) {
-      this._scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
+      this._scripts = HtmlScriptElement.EMPTY_LIST;
       return;
     }
     for (HtmlScriptElement script in scripts) {
       (script as HtmlScriptElementImpl).enclosingElement = this;
     }
     this._scripts = scripts;
   }
 
   @override
   bool operator ==(Object object) {
@@ skipping 20 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
 }
 
 /**
  * A script tag in an HTML file.
  *
  * See [EmbeddedHtmlScriptElement], and [ExternalHtmlScriptElement].
  */
-abstract class HtmlScriptElement implements Element {}
+abstract class HtmlScriptElement implements Element {
+  /**
+   * An empty list of HTML script elements.
+   */
+  static const List<HtmlScriptElement> EMPTY_LIST = const <HtmlScriptElement>[];
+}
 
 /**
  * A concrete implementation of an [HtmlScriptElement].
  */
 abstract class HtmlScriptElementImpl extends ElementImpl
     implements HtmlScriptElement {
   /**
    * An empty list of HTML script elements.
    */
+  @deprecated // Use HtmlScriptElement.EMPTY_LIST
   static const List<HtmlScriptElement> EMPTY_ARRAY =
       const <HtmlScriptElement>[];
 
   /**
    * Initialize a newly created script element corresponding to the given
    * [node].
    */
   HtmlScriptElementImpl(XmlTagNode node)
       : super(node.tag, node.tagToken.offset);
 }
 
 /**
  * A single import directive within a library.
  */
 abstract class ImportElement implements Element, UriReferencedElement {
   /**
    * An empty list of import elements.
    */
+  @deprecated // Use ImportElement.EMPTY_LIST
   static const List<ImportElement> EMPTY_ARRAY = const <ImportElement>[];
 
   /**
+   * An empty list of import elements.
+   */
+  static const List<ImportElement> EMPTY_LIST = const <ImportElement>[];
+
+  /**
    * Return a list containing the combinators that were specified as part of the
    * import directive in the order in which they were specified.
    */
   List<NamespaceCombinator> get combinators;
 
   /**
    * Return the library that is imported into this library by this import
    * directive.
    */
   LibraryElement get importedLibrary;
@@ skipping 30 matching lines @@
 
   /**
    * The library that is imported into this library by this import directive.
    */
   LibraryElement importedLibrary;
 
   /**
    * The combinators that were specified as part of the import directive in the
    * order in which they were specified.
    */
-  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
+  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.
    */
   PrefixElement prefix;
 
   /**
    * Initialize a newly created import element at the given [offset].
    * The offset may be `-1` if the import is synthetic.
@@ skipping 34 matching lines @@
 }
 
 /**
  * The type introduced by either a class or an interface, or a reference to such
  * a type.
  */
 abstract class InterfaceType implements ParameterizedType {
   /**
    * An empty list of types.
    */
+  @deprecated // Use InterfaceType.EMPTY_LIST
   static const List<InterfaceType> EMPTY_ARRAY = const <InterfaceType>[];
 
   /**
+   * An empty list of types.
+   */
+  static const List<InterfaceType> EMPTY_LIST = const <InterfaceType>[];
+
+  /**
    * Return a list containing all of the accessors (getters and setters)
    * declared in this type.
    */
   List<PropertyAccessorElement> get accessors;
 
   @override
   ClassElement get element;
 
   /**
    * Return a list containing all of the interfaces that are implemented by this
@@ skipping 304 matching lines @@
   }
 }
 
 /**
  * A concrete implementation of an [InterfaceType].
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * A list containing the actual types of the type arguments.
    */
-  List<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
+  List<DartType> typeArguments = DartType.EMPTY_LIST;
 
   /**
    * Initialize a newly created type to be declared by the given [element].
    */
   InterfaceTypeImpl.con1(ClassElement element)
       : super(element, element.displayName);
 
   /**
    * Initialize a newly created type to have the given [name]. This constructor
    * should only be used in cases where there is no declaration of the type.
@@ skipping 657 matching lines @@
     result.retainAll(second);
     return new List.from(result);
   }
 }
 
 /**
  * A label associated with a statement.
  */
 abstract class LabelElement implements Element {
   /**
+   * An empty list of label elements.
+   */
+  static const List<LabelElement> EMPTY_LIST = const <LabelElement>[];
+
+  /**
    * Return the executable element in which this label is defined.
    */
   @override
   ExecutableElement get enclosingElement;
 }
 
 /**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * An empty list of label elements.
    */
+  @deprecated // Use LabelElement.EMPTY_LIST
   static const List<LabelElement> EMPTY_ARRAY = const <LabelElement>[];
 
   /**
    * A flag indicating whether this label is associated with a `switch`
    * statement.
    */
   // TODO(brianwilkerson) Make this a modifier.
   final bool _onSwitchStatement;
 
   /**
@@ skipping 33 matching lines @@
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 }
 
 /**
  * A library.
  */
 abstract class LibraryElement implements Element {
   /**
+   * An empty list of library elements.
+   */
+  static const List<LibraryElement> EMPTY_LIST = const <LibraryElement>[];
+
+  /**
    * Return the compilation unit that defines this library.
    */
   CompilationUnitElement get definingCompilationUnit;
 
   /**
    * Return the entry point for this library, or `null` if this library does not
    * have an entry point. The entry point is defined to be a zero argument
    * top-level function whose name is `main`.
    */
   FunctionElement get entryPoint;
@@ skipping 115 matching lines @@
   bool isUpToDate(int timeStamp);
 }
 
 /**
  * A concrete implementation of a [LibraryElement].
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * An empty list of library elements.
    */
+  @deprecated // Use LibraryElement.EMPTY_LIST
   static const List<LibraryElement> EMPTY_ARRAY = const <LibraryElement>[];
 
   /**
    * The analysis context in which this library is defined.
    */
   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.
    */
   FunctionElement entryPoint;
 
   /**
    * A list containing specifications of all of the imports defined in this
    * library.
    */
-  List<ImportElement> _imports = ImportElement.EMPTY_ARRAY;
+  List<ImportElement> _imports = ImportElement.EMPTY_LIST;
 
   /**
    * A list containing specifications of all of the exports defined in this
    * library.
    */
-  List<ExportElement> _exports = ExportElement.EMPTY_ARRAY;
+  List<ExportElement> _exports = ExportElement.EMPTY_LIST;
 
   /**
    * A list containing all of the compilation units that are included in this
    * library using a `part` directive.
    */
-  List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
+  List<CompilationUnitElement> _parts = CompilationUnitElement.EMPTY_LIST;
 
   /**
    * The element representing the synthetic function `loadLibrary` that is
    * defined for this library, or `null` if the element has not yet been created.
    */
   FunctionElement _loadLibraryFunction;
 
   /**
    * The export [Namespace] of this library, `null` if it has not been
    * computed yet.
@@ skipping 426 matching lines @@
    *   potentially visible in multiple sources.
    */
   SourceRange get visibleRange;
 }
 
 /**
  * A local variable.
  */
 abstract class LocalVariableElement implements LocalElement, VariableElement {
   /**
+   * An empty list of field elements.
+   */
+  static const List<LocalVariableElement> EMPTY_LIST =
+      const <LocalVariableElement>[];
+
+  /**
    * Return the resolved [VariableDeclaration] node that declares this
    * [LocalVariableElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   VariableDeclaration get node;
 }
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
     with PotentiallyConstVariableElement implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
+  @deprecated // Use LocalVariableElement.EMPTY_LIST
   static const List<LocalVariableElement> EMPTY_ARRAY =
       const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element
@@ skipping 227 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     // There are no children to visit
   }
 }
 
 /**
  * An element that represents a method defined within a type.
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
   /**
+   * An empty list of method elements.
+   */
+  static const List<MethodElement> EMPTY_LIST = const <MethodElement>[];
+
+  /**
    * Return the resolved [MethodDeclaration] node that declares this
    * [MethodElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   MethodDeclaration get node;
 }
 
 /**
  * A concrete implementation of a [MethodElement].
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty list of method elements.
    */
+  @deprecated // Use MethodElement.EMPTY_LIST
   static const List<MethodElement> EMPTY_ARRAY = const <MethodElement>[];
 
   /**
    * Initialize a newly created method element to have the given [name] at the
    * given [offset].
    */
   MethodElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created method element to have the given [name].
@@ skipping 367 matching lines @@
   @override
   ElementKind get kind => ElementKind.ERROR;
 
   @override
   LibraryElement get library => null;
 
   @override
   ElementLocation get location => null;
 
   @override
-  List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
+  List<ElementAnnotation> get metadata => ElementAnnotation.EMPTY_LIST;
 
   @override
   String get name => _name;
 
   @override
   int get nameOffset => -1;
 
   @override
   AstNode get node => null;
 
@@ skipping 116 matching lines @@
 /**
  * A [MethodElementImpl], with the additional information of a list of
  * [ExecutableElement]s from which this element was composed.
  */
 class MultiplyInheritedMethodElementImpl extends MethodElementImpl
     implements MultiplyInheritedExecutableElement {
   /**
    * A list the array of executable elements that were used to compose this
    * element.
    */
-  List<ExecutableElement> _elements = MethodElementImpl.EMPTY_ARRAY;
+  List<ExecutableElement> _elements = MethodElement.EMPTY_LIST;
 
   MultiplyInheritedMethodElementImpl(Identifier name) : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * A [PropertyAccessorElementImpl], with the additional information of a list of
  * [ExecutableElement]s from which this element was composed.
  */
 class MultiplyInheritedPropertyAccessorElementImpl
     extends PropertyAccessorElementImpl
     implements MultiplyInheritedExecutableElement {
   /**
    * A list the array of executable elements that were used to compose this
    * element.
    */
-  List<ExecutableElement> _elements = PropertyAccessorElementImpl.EMPTY_ARRAY;
+  List<ExecutableElement> _elements = PropertyAccessorElement.EMPTY_LIST;
 
   MultiplyInheritedPropertyAccessorElementImpl(Identifier name)
       : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * An object that controls how namespaces are combined.
  */
 abstract class NamespaceCombinator {
   /**
    * An empty list of namespace combinators.
    */
+  @deprecated // Use NamespaceCombinator.EMPTY_LIST
   static const List<NamespaceCombinator> EMPTY_ARRAY =
       const <NamespaceCombinator>[];
+
+  /**
+   * An empty list of namespace combinators.
+   */
+  static const List<NamespaceCombinator> EMPTY_LIST =
+      const <NamespaceCombinator>[];
 }
 
 /**
  * A parameter defined within an executable element.
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
   /**
+   * An empty list of parameter elements.
+   */
+  static const List<ParameterElement> EMPTY_LIST = const <ParameterElement>[];
+
+  /**
    * Return the Dart code of the default value, or `null` if no default value.
    */
   String get defaultValueCode;
 
   /**
    * Return `true` if this parameter is an initializing formal parameter.
    */
   bool get isInitializingFormal;
 
   @override
@@ skipping 11 matching lines @@
    */
   List<ParameterElement> get parameters;
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
     implements ParameterElement {
   /**
-   * An empty list of field elements.
+   * An empty list of parameter elements.
    */
+  @deprecated // Use ParameterElement.EMPTY_LIST
   static const List<ParameterElement> EMPTY_ARRAY = const <ParameterElement>[];
 
   /**
    * A list containing all of the parameters defined by this parameter element.
    * There will only be parameters if this parameter is a function typed
    * parameter.
    */
-  List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
+  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The kind of this parameter.
    */
   ParameterKind parameterKind;
 
   /**
    * The Dart code of the default value.
    */
   String _defaultValueCode;
@@ skipping 320 matching lines @@
    * initializers.
    */
   Expression get constantInitializer => null;
 }
 
 /**
  * A prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
   /**
+   * An empty list of prefix elements.
+   */
+  static const List<PrefixElement> EMPTY_LIST = const <PrefixElement>[];
+
+  /**
    * Return the library into which other libraries are imported using this
    * prefix.
    */
   @override
   LibraryElement get enclosingElement;
 
   /**
    * Return a list containing all of the libraries that are imported using this
    * prefix.
    */
   List<LibraryElement> get importedLibraries;
 }
 
 /**
  * A concrete implementation of a [PrefixElement].
  */
 class PrefixElementImpl extends ElementImpl implements PrefixElement {
   /**
    * An empty list of prefix elements.
    */
+  @deprecated // Use PrefixElement.EMPTY_LIST
   static const List<PrefixElement> EMPTY_ARRAY = const <PrefixElement>[];
 
   /**
    * A list containing all of the libraries that are imported using this prefix.
    */
-  List<LibraryElement> _importedLibraries = LibraryElementImpl.EMPTY_ARRAY;
+  List<LibraryElement> _importedLibraries = LibraryElement.EMPTY_LIST;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
   PrefixElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   /**
    * Initialize a newly created prefix element to have the given [name].
    */
@@ skipping 41 matching lines @@
  * * Every explicit field is represented by a non-synthetic [FieldElement].
  * * Every explicit field induces a getter and possibly a setter, both of which
  *   are represented by synthetic [PropertyAccessorElement]s.
  * * Every explicit getter or setter is represented by a non-synthetic
  *   [PropertyAccessorElement].
  * * Every explicit getter or setter (or pair thereof if they have the same
  *   name) induces a field that is represented by a synthetic [FieldElement].
  */
 abstract class PropertyAccessorElement implements ExecutableElement {
   /**
+   * An empty list of property accessor elements.
+   */
+  static const List<PropertyAccessorElement> EMPTY_LIST =
+      const <PropertyAccessorElement>[];
+
+  /**
    * Return the accessor representing the getter that corresponds to (has the
    * same name as) this setter, or `null` if this accessor is not a setter or if
    * there is no corresponding getter.
    */
   PropertyAccessorElement get correspondingGetter;
 
   /**
    * Return the accessor representing the setter that corresponds to (has the
    * same name as) this getter, or `null` if this accessor is not a getter or if
    * there is no corresponding setter.
@@ skipping 19 matching lines @@
 }
 
 /**
  * A concrete implementation of a [PropertyAccessorElement].
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl
     implements PropertyAccessorElement {
   /**
    * An empty list of property accessor elements.
    */
+  @deprecated // Use PropertyAccessorElement.EMPTY_LIST
   static const List<PropertyAccessorElement> EMPTY_ARRAY =
       const <PropertyAccessorElement>[];
 
   /**
    * The variable associated with this accessor.
    */
   PropertyInducingElement variable;
 
   /**
    * Initialize a newly created property accessor element to have the given
@@ skipping 270 matching lines @@
  * * Every explicit variable induces a getter and possibly a setter, both of
  *   which are represented by synthetic [PropertyAccessorElement]s.
  * * Every explicit getter or setter is represented by a non-synthetic
  *   [PropertyAccessorElement].
  * * Every explicit getter or setter (or pair thereof if they have the same
  *   name) induces a variable that is represented by a synthetic
  *   [PropertyInducingElement].
  */
 abstract class PropertyInducingElement implements VariableElement {
   /**
+   * An empty list of elements.
+   */
+  static const List<PropertyInducingElement> EMPTY_LIST =
+      const <PropertyInducingElement>[];
+
+  /**
    * Return the getter associated with this variable. If this variable was
    * explicitly defined (is not synthetic) then the getter associated with it
    * will be synthetic.
    */
   PropertyAccessorElement get getter;
 
   /**
    * Return `true` if this element is a static element. A static element is an
    * element that is not associated with a particular instance, but rather with
    * an entire library or class.
@@ skipping 19 matching lines @@
 }
 
 /**
  * A concrete implementation of a [PropertyInducingElement].
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl
     implements PropertyInducingElement {
   /**
    * An empty list of elements.
    */
+  @deprecated // Use PropertyInducingElement.EMPTY_LIST
   static const List<PropertyInducingElement> EMPTY_ARRAY =
       const <PropertyInducingElement>[];
 
   /**
    * The getter associated with this element.
    */
   PropertyAccessorElement getter;
 
   /**
    * The setter associated with this element, or `null` if the element is
@@ skipping 296 matching lines @@
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
   @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
 
 /**
  * A top-level variable.
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
+  /**
+   * An empty list of top-level variable elements.
+   */
+  static const List<TopLevelVariableElement> EMPTY_LIST =
+      const <TopLevelVariableElement>[];
+
   @override
   VariableDeclaration get node;
 }
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
     with PotentiallyConstVariableElement implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
+  @deprecated // Use TopLevelVariableElement.EMPTY_LIST
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
    */
   TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
@@ skipping 17 matching lines @@
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects
  * representing the declared type of elements in the element model.
  */
 abstract class TypeImpl implements DartType {
   /**
    * An empty list of types.
    */
+  @deprecated // Use DartType.EMPTY_LIST
   static const List<DartType> EMPTY_ARRAY = const <DartType>[];
 
   /**
    * The element representing the declaration of this type, or `null` if the
    * type has not, or cannot, be associated with an element.
    */
   final Element _element;
 
   /**
    * The name of this type, or `null` if the type does not have a name.
@@ skipping 171 matching lines @@
     }
     return newTypes;
   }
 }
 
 /**
  * A type parameter.
  */
 abstract class TypeParameterElement implements Element {
   /**
+   * An empty list of type parameter elements.
+   */
+  static const List<TypeParameterElement> EMPTY_LIST =
+      const <TypeParameterElement>[];
+
+  /**
    * Return the type representing the bound associated with this parameter, or
    * `null` if this parameter does not have an explicit bound.
    */
   DartType get bound;
 
   /**
    * Return the type defined by this type parameter.
    */
   TypeParameterType get type;
 }
 
 /**
  * A concrete implementation of a [TypeParameterElement].
  */
 class TypeParameterElementImpl extends ElementImpl
     implements TypeParameterElement {
   /**
    * An empty list of type parameter elements.
    */
+  @deprecated // Use TypeParameterElement.EMPTY_LIST
   static const List<TypeParameterElement> EMPTY_ARRAY =
       const <TypeParameterElement>[];
 
   /**
    * The type defined by this type parameter.
    */
   TypeParameterType type;
 
   /**
    * The type representing the bound associated with this parameter, or `null`
@@ skipping 25 matching lines @@
       buffer.write(" extends ");
       buffer.write(bound);
     }
   }
 }
 
 /**
  * The type introduced by a type parameter.
  */
 abstract class TypeParameterType implements DartType {
+  /**
+   * An empty list of type parameter types.
+   */
+  static const List<TypeParameterType> EMPTY_LIST = const <TypeParameterType>[];
+
   @override
   TypeParameterElement get element;
 }
 
 /**
  * A concrete implementation of a [TypeParameterType].
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty list of type parameter types.
    */
+  @deprecated // Use TypeParameterType.EMPTY_LIST
   static const List<TypeParameterType> EMPTY_ARRAY =
       const <TypeParameterType>[];
 
   /**
    * Initialize a newly created type parameter type to be declared by the given
    * [element] and to have the given name.
    */
   TypeParameterTypeImpl(TypeParameterElement element)
       : super(element, element.name);
 
@@ skipping 88 matching lines @@
   }
 
   /**
    * Return a list containing the type parameter types defined by the given
    * array of type parameter elements ([typeParameters]).
    */
   static List<TypeParameterType> getTypes(
       List<TypeParameterElement> typeParameters) {
     int count = typeParameters.length;
     if (count == 0) {
-      return EMPTY_ARRAY;
+      return TypeParameterType.EMPTY_LIST;
     }
     List<TypeParameterType> types = new List<TypeParameterType>(count);
     for (int i = 0; i < count; i++) {
       types[i] = typeParameters[i].type;
     }
     return types;
   }
 }
 
 /**
@@ skipping 128 matching lines @@
    * [offset]. The offset may be `-1` if the element is synthetic.
    */
   UriReferencedElementImpl(String name, int offset) : super(name, offset);
 }
 
 /**
  * A variable. There are concrete subclasses for different kinds of variables.
  */
 abstract class VariableElement implements Element {
   /**
+   * An empty list of variable elements.
+   */
+  static const List<VariableElement> EMPTY_LIST = const <VariableElement>[];
+
+  /**
    * Return a synthetic function representing this variable's initializer, or
    * `null` if this variable does not have an initializer. The function will
    * have no parameters. The return type of the function will be the
    * compile-time type of the initialization expression.
    */
   FunctionElement get initializer;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    */
@@ skipping 31 matching lines @@
 }
 
 /**
  * A concrete implementation of a [VariableElement].
  */
 abstract class VariableElementImpl extends ElementImpl
     implements VariableElement {
   /**
    * An empty list of variable elements.
    */
+  @deprecated // Use VariableElement.EMPTY_LIST
   static const List<VariableElement> EMPTY_ARRAY = const <VariableElement>[];
 
   /**
    * The declared type of this variable.
    */
   DartType type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if
    * this variable does not have an initializer.
@@ skipping 207 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }