Make constant lists immutable

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 262 matching lines @@
   @override
   String get identifier => "Decorator@$_offset";
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular specific element.
  */
 abstract class AngularElement implements ToolkitObjectElement {
   /**
-   * An empty array of Angular elements.
+   * An empty list of Angular elements.
    */
-  static final List<AngularElement> EMPTY_ARRAY = new List<AngularElement>(0);
+  static const List<AngularElement> EMPTY_ARRAY = const <AngularElement>[];
 
   /**
    * Returns the [AngularApplication] this element is used in.
    *
    * @return the [AngularApplication] this element is used in
    */
   AngularApplication get application;
 }
 
 /**
@@ skipping 167 matching lines @@
    */
   int get templateUriOffset;
 }
 
 /**
  * The interface `AngularPropertyElement` defines a single property in
  * [AngularComponentElement].
  */
 abstract class AngularPropertyElement implements AngularElement {
   /**
-   * An empty array of property elements.
+   * An empty list of property elements.
    */
-  static final List<AngularPropertyElement> EMPTY_ARRAY = <AngularPropertyElement>[];
+  static const List<AngularPropertyElement> EMPTY_ARRAY = const <AngularPropertyElement>[];
 
   /**
    * Returns the field this property is mapped to.
    *
    * @return the field this property is mapped to.
    */
   FieldElement get field;
 
   /**
    * Return the offset of the field name of this property in the property map, or `-1` if
@@ skipping 101 matching lines @@
   @override
   bool callsGetter() => true;
 }
 
 /**
  * The interface `AngularScopeVariableElement` defines the Angular <code>Scope</code>
  * property. They are created for every <code>scope['property'] = value;</code> code snippet.
  */
 abstract class AngularScopePropertyElement implements AngularElement {
   /**
-   * An empty array of scope property elements.
+   * An empty list of scope property elements.
    */
-  static final List<AngularScopePropertyElement> EMPTY_ARRAY = <AngularScopePropertyElement>[];
+  static const List<AngularScopePropertyElement> EMPTY_ARRAY = const <AngularScopePropertyElement>[];
 
   /**
    * Returns the type of this property, not `null`, maybe <code>dynamic</code>.
    *
    * @return the type of this property.
    */
   DartType get type;
 }
 
 /**
@@ skipping 78 matching lines @@
   @override
   AngularApplication get application => (enclosingElement as AngularElementImpl).application;
 }
 
 /**
  * The interface `AngularViewElement` defines the Angular view defined using invocation like
  * <code>view('views/create.html')</code>.
  */
 abstract class AngularViewElement implements AngularHasTemplateElement {
   /**
-   * An empty array of view elements.
+   * An empty list of view elements.
    */
-  static final List<AngularViewElement> EMPTY_ARRAY = new List<AngularViewElement>(0);
+  static const List<AngularViewElement> EMPTY_ARRAY = const <AngularViewElement>[];
 }
 
 /**
  * Implementation of `AngularViewElement`.
  */
 class AngularViewElementImpl extends AngularElementImpl implements AngularViewElement {
   /**
    * The HTML template URI.
    */
   final String templateUri;
@@ skipping 550 matching lines @@
    * The type defined by the class.
    */
   InterfaceType type;
 
   /**
    * An array containing all of the type parameters defined for this class.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
-   * An empty array of class elements.
+   * An empty list of class elements.
    */
-  static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
+  static const List<ClassElement> EMPTY_ARRAY = const <ClassElement>[];
 
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
    */
   ClassElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created class element to have the given name.
@@ skipping 718 matching lines @@
    */
   bool get hasLoadLibraryFunction;
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
  */
 class CompilationUnitElementImpl extends UriReferencedElementImpl implements CompilationUnitElement {
   /**
-   * An empty array of compilation unit elements.
+   * An empty list of compilation unit elements.
    */
-  static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
+  static const List<CompilationUnitElement> EMPTY_ARRAY = const <CompilationUnitElement>[];
 
   /**
    * The source that corresponds to this compilation unit.
    */
   Source source;
 
   /**
    * An array containing all of the top-level accessors (getters and setters) contained in this
    * compilation unit.
    */
@@ skipping 416 matching lines @@
    * @return `true` if this constructor represents a factory constructor
    */
   bool get isFactory;
 }
 
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
-   * An empty array of constructor elements.
+   * An empty list of constructor elements.
    */
-  static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
+  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 instance creation
    * expressions).
    */
@@ skipping 713 matching lines @@
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
   final Element element;
 
   /**
-   * An empty array of annotations.
+   * An empty list of annotations.
    */
-  static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
+  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 deprecated.
    */
   static String _DEPRECATED_VARIABLE_NAME = "deprecated";
@@ skipping 993 matching lines @@
    * The return type defined by this executable element.
    */
   DartType returnType;
 
   /**
    * The type of function defined by this executable element.
    */
   FunctionType type;
 
   /**
-   * An empty array of executable elements.
+   * An empty list of executable elements.
    */
-  static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
+  static const List<ExecutableElement> EMPTY_ARRAY = const <ExecutableElement>[];
 
   /**
    * Initialize a newly created executable element to have the given name.
    *
    * @param name the name of this element
    */
   ExecutableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created executable element to have the given name.
@@ skipping 255 matching lines @@
     safelyVisitChildren(parameters, visitor);
   }
 }
 
 /**
  * The interface `ExportElement` defines the behavior of objects representing information
  * about a single export directive within a library.
  */
 abstract class ExportElement implements Element, UriReferencedElement {
   /**
-   * An empty array of export elements.
+   * An empty list of export elements.
    */
-  static final List<ExportElement> EMPTY_ARRAY = new List<ExportElement>(0);
+  static const List<ExportElement> EMPTY_ARRAY = const <ExportElement>[];
 
   /**
    * Return an array containing the combinators that were specified as part of the export directive
    * in the order in which they were specified.
    *
    * @return the combinators specified in the export directive
    */
   List<NamespaceCombinator> get combinators;
 
   /**
@@ skipping 84 matching lines @@
  * within a type.
  */
 abstract class FieldElement implements ClassMemberElement, PropertyInducingElement {
 }
 
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
-   * An empty array of field elements.
+   * An empty list of field elements.
    */
-  static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
+  static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created field element to have the given name.
    *
    * @param name the name of this element
    */
   FieldElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic field element to have the given name.
@@ skipping 228 matching lines @@
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
-   * An empty array of function elements.
+   * An empty list of function elements.
    */
-  static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
+  static const List<FunctionElement> EMPTY_ARRAY = const <FunctionElement>[];
 
   /**
    * Initialize a newly created function element to have the given name.
    *
    * @param name the name of this element
    */
   FunctionElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
@@ skipping 1287 matching lines @@
    * @return the script elements in the HTML file (not `null`, contains no `null`s)
    */
   List<HtmlScriptElement> get scripts;
 }
 
 /**
  * Instances of the class `HtmlElementImpl` implement an [HtmlElement].
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
-   * An empty array of HTML file elements.
+   * An empty list of HTML file elements.
    */
-  static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
+  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;
@@ skipping 105 matching lines @@
  * See [EmbeddedHtmlScriptElement], and [ExternalHtmlScriptElement],
  */
 abstract class HtmlScriptElement implements Element {
 }
 
 /**
  * Instances of the class `HtmlScriptElementImpl` implement an [HtmlScriptElement].
  */
 abstract class HtmlScriptElementImpl extends ElementImpl implements HtmlScriptElement {
   /**
-   * An empty array of HTML script elements.
+   * An empty list of HTML script elements.
    */
-  static List<HtmlScriptElement> EMPTY_ARRAY = new List<HtmlScriptElement>(0);
+  static const List<HtmlScriptElement> EMPTY_ARRAY = const <HtmlScriptElement>[];
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   HtmlScriptElementImpl(XmlTagNode node) : super(node.tag, node.tagToken.offset);
 }
 
 /**
  * The interface `ImportElement` defines the behavior of objects representing information
  * about a single import directive within a library.
  */
 abstract class ImportElement implements Element, UriReferencedElement {
   /**
-   * An empty array of import elements.
+   * An empty list of import elements.
    */
-  static final List<ImportElement> EMPTY_ARRAY = new List<ImportElement>(0);
+  static const List<ImportElement> EMPTY_ARRAY = const<ImportElement>[];
 
   /**
    * Return an array containing the combinators that were specified as part of the import directive
    * in the order in which they were specified.
    *
    * @return the combinators specified in the import directive
    */
   List<NamespaceCombinator> get combinators;
 
   /**
@@ skipping 95 matching lines @@
   @override
   String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@$nameOffset";
 }
 
 /**
  * The interface `InterfaceType` defines the behavior common to objects representing the type
  * introduced by either a class or an interface, or a reference to such a type.
  */
 abstract class InterfaceType implements ParameterizedType {
   /**
-   * An empty array of types.
+   * An empty list of types.
    */
-  static final List<InterfaceType> EMPTY_ARRAY = new List<InterfaceType>(0);
+  static const List<InterfaceType> EMPTY_ARRAY = const <InterfaceType>[];
 
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this type.
    *
    * @return the accessors declared in this type
    */
   List<PropertyAccessorElement> get accessors;
 
   @override
   ClassElement get element;
@@ skipping 1070 matching lines @@
    */
   final bool _onSwitchStatement;
 
   /**
    * A flag indicating whether this label is associated with a `switch` member (`case`
    * or `default`).
    */
   final bool _onSwitchMember;
 
   /**
-   * An empty array of label elements.
+   * An empty list of label elements.
    */
-  static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>(0);
+  static const List<LabelElement> EMPTY_ARRAY = const <LabelElement>[];
 
   /**
    * Initialize a newly created label element to have the given name.
    *
    * @param name the name of this element
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
   LabelElementImpl(Identifier name, this._onSwitchStatement, this._onSwitchMember) : super.forNode(name);
@@ skipping 178 matching lines @@
    * @return `true` if this library is up to date with respect to the given time stamp
    */
   bool isUpToDate(int timeStamp);
 }
 
 /**
  * Instances of the class `LibraryElementImpl` implement a `LibraryElement`.
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
-   * An empty array of library elements.
+   * An empty list of library elements.
    */
-  static List<LibraryElement> EMPTY_ARRAY = new List<LibraryElement>(0);
+  static const List<LibraryElement> EMPTY_ARRAY = const <LibraryElement>[];
 
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
    * @param library the library to process
    * @param timeStamp the time stamp to check against
    * @param visitedLibraries the set of visited libraries
    */
   static bool _safeIsUpToDate(LibraryElement library, int timeStamp, Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.contains(library)) {
@@ skipping 481 matching lines @@
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
-   * An empty array of field elements.
+   * An empty list of field elements.
    */
-  static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
+  static const List<LocalVariableElement> EMPTY_ARRAY = const <LocalVariableElement>[];
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
   LocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created method element to have the given name.
@@ skipping 268 matching lines @@
    * @return `true` if this method is abstract
    */
   bool get isAbstract;
 }
 
 /**
  * Instances of the class `MethodElementImpl` implement a `MethodElement`.
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
-   * An empty array of method elements.
+   * An empty list of method elements.
    */
-  static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
+  static const List<MethodElement> EMPTY_ARRAY = const <MethodElement>[];
 
   /**
    * Initialize a newly created method element to have the given name.
    *
    * @param name the name of this element
    */
   MethodElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created method element to have the given name.
@@ skipping 552 matching lines @@
     this._elements = elements;
   }
 }
 
 /**
  * The interface `NamespaceCombinator` defines the behavior common to objects that control how
  * namespaces are combined.
  */
 abstract class NamespaceCombinator {
   /**
-   * An empty array of namespace combinators.
+   * An empty list of namespace combinators.
    */
   static const List<NamespaceCombinator> EMPTY_ARRAY = const <NamespaceCombinator>[];
 }
 
 /**
  * The interface `ParameterElement` defines the behavior of elements representing a parameter
  * defined within an executable element.
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
   /**
@@ skipping 51 matching lines @@
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
-   * An empty array of field elements.
+   * An empty list of field elements.
    */
-  static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
+  static const List<ParameterElement> EMPTY_ARRAY = const<ParameterElement>[];
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   ParameterElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created parameter element to have the given name.
@@ skipping 290 matching lines @@
  * The interface `PolymerAttributeElement` defines an attribute in
  * [PolymerTagHtmlElement].
  *
  * <pre>
  * <polymer-element name="my-example" attributes='attrA attrB'>
  * </polymer-element>
  * </pre>
  */
 abstract class PolymerAttributeElement implements PolymerElement {
   /**
-   * An empty array of Polymer custom tag attributes.
+   * An empty list of Polymer custom tag attributes.
    */
-  static final List<PolymerAttributeElement> EMPTY_ARRAY = new List<PolymerAttributeElement>(0);
+  static const List<PolymerAttributeElement> EMPTY_ARRAY = const <PolymerAttributeElement>[];
 
   /**
    * Return the [FieldElement] associated with this attribute. Maybe `null` if
    * [PolymerTagDartElement] does not have a field associated with it.
    */
   FieldElement get field;
 }
 
 /**
  * Implementation of `PolymerAttributeElement`.
@@ skipping 19 matching lines @@
   @override
   ElementKind get kind => ElementKind.POLYMER_ATTRIBUTE;
 }
 
 /**
  * The interface `PolymerElement` defines the behavior of objects representing information
  * about a Polymer specific element.
  */
 abstract class PolymerElement implements ToolkitObjectElement {
   /**
-   * An empty array of Polymer elements.
+   * An empty list of Polymer elements.
    */
-  static final List<PolymerElement> EMPTY_ARRAY = new List<PolymerElement>(0);
+  static const List<PolymerElement> EMPTY_ARRAY = const <PolymerElement>[];
 }
 
 /**
  * Implementation of `PolymerElement`.
  */
 abstract class PolymerElementImpl extends ToolkitObjectElementImpl implements PolymerElement {
   /**
    * Initialize a newly created Polymer element to have the given name.
    *
    * @param name the name of this element
@@ skipping 59 matching lines @@
 /**
  * The interface `PolymerTagHtmlElement` defines a Polymer custom tag in HTML.
  *
  * <pre>
  * <polymer-element name="my-example" attributes='attrA attrB'>
  * </polymer-element>
  * </pre>
  */
 abstract class PolymerTagHtmlElement implements PolymerElement {
   /**
-   * An empty array of [PolymerTagHtmlElement]s.
+   * An empty list of [PolymerTagHtmlElement]s.
    */
-  static final List<PolymerTagHtmlElement> EMPTY_ARRAY = new List<PolymerTagHtmlElement>(0);
+  static const List<PolymerTagHtmlElement> EMPTY_ARRAY = const <PolymerTagHtmlElement>[];
 
   /**
    * Return an array containing all of the attributes declared by this tag.
    */
   List<PolymerAttributeElement> get attributes;
 
   /**
    * Return the [PolymerTagDartElement] part on this Polymer custom tag. Maybe `null` if
    * it has not been resolved yet or there are no corresponding Dart part defined.
    */
@@ skipping 76 matching lines @@
 /**
  * Instances of the class `PrefixElementImpl` implement a `PrefixElement`.
  */
 class PrefixElementImpl extends ElementImpl implements PrefixElement {
   /**
    * An array containing all of the libraries that are imported using this prefix.
    */
   List<LibraryElement> _importedLibraries = LibraryElementImpl.EMPTY_ARRAY;
 
   /**
-   * An empty array of prefix elements.
+   * An empty list of prefix elements.
    */
-  static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>(0);
+  static const List<PrefixElement> EMPTY_ARRAY = const <PrefixElement>[];
 
   /**
    * Initialize a newly created prefix element to have the given name.
    *
    * @param name the name of this element
    */
   PrefixElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created method element to have the given name.
@@ skipping 105 matching lines @@
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
    */
   PropertyInducingElement variable;
 
   /**
-   * An empty array of property accessor elements.
+   * An empty list of property accessor elements.
    */
-  static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
+  static const List<PropertyAccessorElement> EMPTY_ARRAY = const <PropertyAccessorElement>[];
 
   /**
    * Initialize a newly created property accessor element to have the given name.
    *
    * @param name the name of this element
    */
   PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
@@ skipping 332 matching lines @@
    */
   PropertyAccessorElement setter;
 
   /**
    * The propagated type of this variable, or `null` if type propagation has not been
    * performed.
    */
   DartType propagatedType;
 
   /**
-   * An empty array of elements.
+   * An empty list of elements.
    */
-  static List<PropertyInducingElement> EMPTY_ARRAY = new List<PropertyInducingElement>(0);
+  static const List<PropertyInducingElement> EMPTY_ARRAY = const <PropertyInducingElement>[];
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic element to have the given name.
@@ skipping 386 matching lines @@
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
 
 /**
  * The interface `ToolkitObjectElement` defines the behavior of elements that represent a
  * toolkit specific object, such as Angular controller or component. These elements are not based on
  * the Dart syntax, but on some semantic agreement, such as a special annotation.
  */
 abstract class ToolkitObjectElement implements Element {
   /**
-   * An empty array of toolkit object elements.
+   * An empty list of toolkit object elements.
    */
-  static final List<ToolkitObjectElement> EMPTY_ARRAY = new List<ToolkitObjectElement>(0);
+  static const List<ToolkitObjectElement> EMPTY_ARRAY = const <ToolkitObjectElement>[];
 }
 
 /**
  * Instances of the class `ToolkitObjectElementImpl` implement a `ToolkitObjectElement`.
  */
 abstract class ToolkitObjectElementImpl extends ElementImpl implements ToolkitObjectElement {
   /**
    * Initialize a newly created toolkit object element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ToolkitObjectElementImpl(String name, int nameOffset) : super(name, nameOffset);
 }
 
 /**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
 }
 
 /**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
-   * An empty array of top-level variable elements.
+   * An empty list of top-level variable elements.
    */
-  static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
+  static const List<TopLevelVariableElement> EMPTY_ARRAY = const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the given name.
@@ skipping 72 matching lines @@
    * cannot, be associated with an element.
    */
   final Element _element;
 
   /**
    * The name of this type, or `null` if the type does not have a name.
    */
   final String name;
 
   /**
-   * An empty array of types.
+   * An empty list of types.
    */
-  static List<DartType> EMPTY_ARRAY = new List<DartType>(0);
+  static const List<DartType> EMPTY_ARRAY = const <DartType>[];
 
   /**
    * Initialize a newly created type to be declared by the given element and to have the given name.
    *
    * @param element the element representing the declaration of the type
    * @param name the name of the type
    */
   TypeImpl(this._element, this.name);
 
   @override
@@ skipping 226 matching lines @@
    */
   TypeParameterType type;
 
   /**
    * The type representing the bound associated with this parameter, or `null` if this
    * parameter does not have an explicit bound.
    */
   DartType bound;
 
   /**
-   * An empty array of type parameter elements.
+   * An empty list of type parameter elements.
    */
-  static List<TypeParameterElement> EMPTY_ARRAY = new List<TypeParameterElement>(0);
+  static const List<TypeParameterElement> EMPTY_ARRAY = const <TypeParameterElement>[];
 
   /**
    * Initialize a newly created type parameter element to have the given name.
    *
    * @param name the name of this element
    */
   TypeParameterElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created method element to have the given name.
@@ skipping 28 matching lines @@
   @override
   TypeParameterElement get element;
 }
 
 /**
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
-   * An empty array of type parameter types.
+   * An empty list of type parameter types.
    */
-  static List<TypeParameterType> EMPTY_ARRAY = new List<TypeParameterType>(0);
+  static const List<TypeParameterType> EMPTY_ARRAY = const <TypeParameterType>[];
 
   /**
    * Return an array containing the type parameter types defined by the given array of type
    * parameter elements.
    *
    * @param typeParameters the type parameter elements defining the type parameter types to be
    *          returned
    * @return the type parameter types defined by the type parameter elements
    */
   static List<TypeParameterType> getTypes(List<TypeParameterElement> typeParameters) {
@@ skipping 501 matching lines @@
    */
   DartType type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if this variable
    * does not have an initializer.
    */
   FunctionElement _initializer;
 
   /**
-   * An empty array of variable elements.
+   * An empty list of variable elements.
    */
-  static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
+  static const List<VariableElement> EMPTY_ARRAY = const <VariableElement>[];
 
   /**
    * Initialize a newly created variable element to have the given name.
    *
    * @param name the name of this element
    */
   VariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created variable element to have the given name.
@@ skipping 198 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }