Change new List(n) to return fixed length list.

pkg/analyzer-experimental/lib/src/generated/element.dart

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
@@ skipping 381 matching lines @@
   FunctionType get type;
 }
 /**
  * The interface {@code ExportElement} defines the behavior of objects representing information
  * about a single export directive within a library.
  */
 abstract class ExportElement implements Element {
   /**
    * An empty array of export elements.
    */
-  static List<ExportElement> EMPTY_ARRAY = new List<ExportElement>.fixedLength(0);
+  static List<ExportElement> EMPTY_ARRAY = new List<ExportElement>(0);
   /**
    * 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;
   /**
    * Return the library that is exported from this library by this export directive.
    * @return the library that is exported from this library
    */
@@ skipping 78 matching lines @@
   List<LibraryElement> get libraries;
 }
 /**
  * The interface {@code ImportElement} defines the behavior of objects representing information
  * about a single import directive within a library.
  */
 abstract class ImportElement implements Element {
   /**
    * An empty array of import elements.
    */
-  static List<ImportElement> EMPTY_ARRAY = new List<ImportElement>.fixedLength(0);
+  static List<ImportElement> EMPTY_ARRAY = new List<ImportElement>(0);
   /**
    * 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;
   /**
    * Return the library that is imported into this library by this import directive.
    * @return the library that is imported into this library
    */
@@ skipping 110 matching lines @@
   List<Element> get conflictingElements;
 }
 /**
  * The interface {@code NamespaceCombinator} defines the behavior common to objects that control how
  * namespaces are combined.
  */
 abstract class NamespaceCombinator {
   /**
    * An empty array of namespace combinators.
    */
-  static List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>.fixedLength(0);
+  static List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
 }
 /**
  * The interface {@code ParameterElement} defines the behavior of elements representing a parameter
  * defined within an executable element.
  */
 abstract class ParameterElement implements VariableElement {
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
@@ skipping 165 matching lines @@
  * Instances of the class {@code AnnotationImpl} implement an {@link Annotation}.
  */
 class AnnotationImpl implements Annotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
   Element _element;
   /**
    * An empty array of annotations.
    */
-  static List<AnnotationImpl> EMPTY_ARRAY = new List<AnnotationImpl>.fixedLength(0);
+  static List<AnnotationImpl> EMPTY_ARRAY = new List<AnnotationImpl>(0);
   /**
    * Initialize a newly created annotation.
    * @param element the element representing the field, variable, or constructor being used as an
    * annotation
    */
   AnnotationImpl(Element element) {
     this._element = element;
   }
   Element get element => _element;
   String toString() => "@${_element.toString()}";
@@ skipping 35 matching lines @@
    * The type defined by the class.
    */
   InterfaceType _type;
   /**
    * An array containing all of the type variables defined for this class.
    */
   List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.EMPTY_ARRAY;
   /**
    * An empty array of type elements.
    */
-  static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>.fixedLength(0);
+  static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
   /**
    * Initialize a newly created class element to have the given name.
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.con1(name) {
   }
   List<PropertyAccessorElement> get accessors => _accessors;
   List<InterfaceType> get allSupertypes {
     Collection<InterfaceType> list = new Set<InterfaceType>();
     collectAllSupertypes(list);
@@ skipping 321 matching lines @@
    * An array containing all of the type aliases contained in this compilation unit.
    */
   List<TypeAliasElement> _typeAliases = TypeAliasElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
   /**
    * An empty array of compilation unit elements.
    */
-  static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>.fixedLength(0);
+  static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
   /**
    * Initialize a newly created compilation unit element to have the given name.
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super.con2(name, -1) {
   }
   bool operator ==(Object object) => identical(this.runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
   List<PropertyAccessorElement> get accessors => _accessors;
   ElementImpl getChild(String identifier20) {
     for (PropertyAccessorElement accessor in _accessors) {
@@ skipping 98 matching lines @@
     }
   }
 }
 /**
  * Instances of the class {@code ConstructorElementImpl} implement a {@code ConstructorElement}.
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
-  static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>.fixedLength(0);
+  static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
   /**
    * Initialize a newly created constructor element to have the given name.
    * @param name the name of this element
    */
   ConstructorElementImpl(Identifier name) : super.con1(name) {
   }
   ClassElement get enclosingElement => (super.enclosingElement as ClassElement);
   ElementKind get kind => ElementKind.CONSTRUCTOR;
   bool isConst() => hasModifier(Modifier.CONST);
   bool isFactory() => hasModifier(Modifier.FACTORY);
@@ skipping 336 matching lines @@
    * An array containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
   /**
    * The type of function defined by this executable element.
    */
   FunctionType _type;
   /**
    * An empty array of executable elements.
    */
-  static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>.fixedLength(0);
+  static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
   /**
    * Initialize a newly created executable element to have the given name.
    * @param name the name of this element
    */
   ExecutableElementImpl.con1(Identifier name) : super.con1(name) {
     _jtd_constructor_139_impl(name);
   }
   _jtd_constructor_139_impl(Identifier name) {
   }
   /**
@@ skipping 148 matching lines @@
    * The getter associated with this field.
    */
   PropertyAccessorElement _getter;
   /**
    * The setter associated with this field, or {@code null} if the field is effectively{@code final} and therefore does not have a setter associated with it.
    */
   PropertyAccessorElement _setter;
   /**
    * An empty array of field elements.
    */
-  static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>.fixedLength(0);
+  static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
   /**
    * Initialize a newly created field element to have the given name.
    * @param name the name of this element
    */
   FieldElementImpl.con1(Identifier name) : super.con1(name) {
     _jtd_constructor_142_impl(name);
   }
   _jtd_constructor_142_impl(Identifier name) {
   }
   /**
@@ skipping 41 matching lines @@
    */
   int _visibleRangeOffset = 0;
   /**
    * The length of the visible range for this element, or {@code -1} if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
   /**
    * An empty array of function elements.
    */
-  static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>.fixedLength(0);
+  static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
   /**
    * Initialize a newly created synthetic function element.
    */
   FunctionElementImpl() : super.con2("", -1) {
     _jtd_constructor_144_impl();
   }
   _jtd_constructor_144_impl() {
     synthetic = true;
   }
   /**
@@ skipping 68 matching lines @@
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code HtmlElementImpl} implement an {@link HtmlElement}.
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
    */
-  static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>.fixedLength(0);
+  static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
   /**
    * The analysis context in which this library is defined.
    */
   AnalysisContext _context;
   /**
    * The libraries contained in or referenced from script tags in the HTML file.
    */
   List<LibraryElement> _libraries = LibraryElementImpl.EMPTY_ARRAY;
   /**
    * The source that corresponds to this HTML file.
@@ skipping 99 matching lines @@
    * A flag indicating whether this label is associated with a {@code switch} statement.
    */
   bool _onSwitchStatement = false;
   /**
    * A flag indicating whether this label is associated with a {@code switch} member ({@code case}or {@code default}).
    */
   bool _onSwitchMember = false;
   /**
    * An empty array of label elements.
    */
-  static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>.fixedLength(0);
+  static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>(0);
   /**
    * Initialize a newly created label element to have the given name.
    * @param name the name of this element
    * @param onSwitchStatement {@code true} if this label is associated with a {@code switch}statement
    * @param onSwitchMember {@code true} if this label is associated with a {@code switch} member
    */
   LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.con1(name) {
     this._onSwitchStatement = onSwitchStatement;
     this._onSwitchMember = onSwitchMember;
   }
@@ skipping 10 matching lines @@
    */
   bool isOnSwitchStatement() => _onSwitchStatement;
 }
 /**
  * Instances of the class {@code LibraryElementImpl} implement a {@code LibraryElement}.
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * An empty array of library elements.
    */
-  static List<LibraryElement> EMPTY_ARRAY = new List<LibraryElement>.fixedLength(0);
+  static List<LibraryElement> EMPTY_ARRAY = new List<LibraryElement>(0);
   /**
    * The analysis context in which this library is defined.
    */
   AnalysisContext _context;
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
   /**
    * The entry point for this library, or {@code null} if this library does not have an entry point.
@@ skipping 135 matching lines @@
     return false;
   }
 }
 /**
  * Instances of the class {@code MethodElementImpl} implement a {@code MethodElement}.
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
-  static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>.fixedLength(0);
+  static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
   /**
    * Initialize a newly created method element to have the given name.
    * @param name the name of this element
    */
   MethodElementImpl.con1(Identifier name) : super.con1(name) {
     _jtd_constructor_151_impl(name);
   }
   _jtd_constructor_151_impl(Identifier name) {
   }
   /**
@@ skipping 147 matching lines @@
  * Instances of the class {@code ParameterElementImpl} implement a {@code ParameterElement}.
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
   /**
    * The kind of this parameter.
    */
   ParameterKind _parameterKind;
   /**
    * An empty array of field elements.
    */
-  static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>.fixedLength(0);
+  static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
   /**
    * Initialize a newly created parameter element to have the given name.
    * @param name the name of this element
    */
   ParameterElementImpl(Identifier name) : super.con1(name) {
   }
   ElementKind get kind => ElementKind.PARAMETER;
   ParameterKind get parameterKind => _parameterKind;
   bool isInitializingFormal() => hasModifier(Modifier.INITIALIZING_FORMAL);
   /**
@@ skipping 23 matching lines @@
  * Instances of the class {@code PrefixElementImpl} implement a {@code 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.
    */
-  static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>.fixedLength(0);
+  static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>(0);
   /**
    * Initialize a newly created prefix element to have the given name.
    * @param name the name of this element
    */
   PrefixElementImpl(Identifier name) : super.con1(name) {
   }
   LibraryElement get enclosingElement => (super.enclosingElement as LibraryElement);
   List<LibraryElement> get importedLibraries => _importedLibraries;
   ElementKind get kind => ElementKind.PREFIX;
   /**
@@ skipping 15 matching lines @@
  * Instances of the class {@code PropertyAccessorElementImpl} implement a{@code PropertyAccessorElement}.
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The field associated with this accessor.
    */
   FieldElement _field;
   /**
    * An empty array of property accessor elements.
    */
-  static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>.fixedLength(0);
+  static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * field.
    * @param name the name of this element
    */
   PropertyAccessorElementImpl.con1(FieldElementImpl field2) : super.con2(field2.name, -1) {
     _jtd_constructor_157_impl(field2);
   }
   _jtd_constructor_157_impl(FieldElementImpl field2) {
     this._field = field2;
@@ skipping 92 matching lines @@
    * The type of function defined by this type alias.
    */
   FunctionType _type;
   /**
    * An array containing all of the type variables defined for this type.
    */
   List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.EMPTY_ARRAY;
   /**
    * An empty array of type alias elements.
    */
-  static List<TypeAliasElement> EMPTY_ARRAY = new List<TypeAliasElement>.fixedLength(0);
+  static List<TypeAliasElement> EMPTY_ARRAY = new List<TypeAliasElement>(0);
   /**
    * Initialize a newly created type alias element to have the given name.
    * @param name the name of this element
    */
   TypeAliasElementImpl(Identifier name) : super.con1(name) {
   }
   ElementImpl getChild(String identifier23) {
     for (VariableElement parameter in _parameters) {
       if (((parameter as VariableElementImpl)).identifier == identifier23) {
         return (parameter as VariableElementImpl);
@@ skipping 78 matching lines @@
    */
   TypeVariableType _type;
   /**
    * The type representing the bound associated with this variable, or {@code null} if this variable
    * does not have an explicit bound.
    */
   Type2 _bound;
   /**
    * An empty array of type variable elements.
    */
-  static List<TypeVariableElement> EMPTY_ARRAY = new List<TypeVariableElement>.fixedLength(0);
+  static List<TypeVariableElement> EMPTY_ARRAY = new List<TypeVariableElement>(0);
   /**
    * Initialize a newly created type variable element to have the given name.
    * @param name the name of this element
    */
   TypeVariableElementImpl(Identifier name) : super.con1(name) {
   }
   Type2 get bound => _bound;
   ElementKind get kind => ElementKind.TYPE_VARIABLE;
   TypeVariableType get type => _type;
   /**
@@ skipping 36 matching lines @@
    */
   int _visibleRangeOffset = 0;
   /**
    * The length of the visible range for this element, or {@code -1} if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
   /**
    * An empty array of variable elements.
    */
-  static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>.fixedLength(0);
+  static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
   /**
    * Initialize a newly created variable element to have the given name.
    * @param name the name of this element
    */
   VariableElementImpl.con1(Identifier name) : super.con1(name) {
     _jtd_constructor_162_impl(name);
   }
   _jtd_constructor_162_impl(Identifier name) {
   }
   /**
@@ skipping 390 matching lines @@
 }
 /**
  * Instances of the class {@code InterfaceTypeImpl} defines the behavior common to objects
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * An empty array of types.
    */
-  static List<InterfaceType> EMPTY_ARRAY = new List<InterfaceType>.fixedLength(0);
+  static List<InterfaceType> EMPTY_ARRAY = new List<InterfaceType>(0);
   /**
    * This method computes the longest inheritance path from some passed {@link Type} to Object.
    * @param type the {@link Type} to compute the longest inheritance path of from the passed{@link Type} to Object
    * @return the computed longest inheritance path to Object
    * @see #computeLongestInheritancePathToObject(Type,int)
    * @see InterfaceType#getLeastUpperBound(Type)
    */
   static int computeLongestInheritancePathToObject(InterfaceType type) => computeLongestInheritancePathToObject2(type, 0);
   /**
    * Returns the set of all superinterfaces of the passed {@link Type}.
@@ skipping 102 matching lines @@
     }
     InterfaceType i = this;
     InterfaceType j = (type as InterfaceType);
     Set<InterfaceType> si = computeSuperinterfaceSet(i);
     Set<InterfaceType> sj = computeSuperinterfaceSet(j);
     javaSetAdd(si, i);
     javaSetAdd(sj, j);
     si.retainAll(sj);
     Set<InterfaceType> s = si;
     List<InterfaceType> sn = new List.from(s);
-    List<int> depths = new List<int>.fixedLength(sn.length);
+    List<int> depths = new List<int>(sn.length);
     int maxDepth = 0;
     for (int n = 0; n < sn.length; n++) {
       depths[n] = computeLongestInheritancePathToObject(sn[n]);
       if (depths[n] > maxDepth) {
         maxDepth = depths[n];
       }
     }
     for (; maxDepth >= 0; maxDepth--) {
       int indexOfLeastUpperBound = -1;
       int numberOfTypesAtMaxDepth = 0;
@@ skipping 169 matching lines @@
   /**
    * Return an array containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the given types.
    * @param types the types on which a substitution is to be performed
    * @param argumentTypes the argument types for the substitution
    * @param parameterTypes the parameter types for the substitution
    * @return the result of performing the substitution on each of the types
    */
   static List<Type2> substitute(List<Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length6 = types.length;
-    List<Type2> newTypes = new List<Type2>.fixedLength(length6);
+    List<Type2> newTypes = new List<Type2>(length6);
     for (int i = 0; i < length6; i++) {
       newTypes[i] = types[i].substitute2(argumentTypes, parameterTypes);
     }
     return newTypes;
   }
   /**
    * The element representing the declaration of this type, or {@code null} if the type has not, or
    * cannot, be associated with an element.
    */
   Element _element;
   /**
    * The name of this type, or {@code null} if the type does not have a name.
    */
   String _name;
   /**
    * An empty array of types.
    */
-  static List<Type2> EMPTY_ARRAY = new List<Type2>.fixedLength(0);
+  static List<Type2> EMPTY_ARRAY = new List<Type2>(0);
   /**
    * 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(Element element, String name) {
     this._element = element;
     this._name = name;
   }
   Element get element => _element;
@@ skipping 25 matching lines @@
  */
 class TypeVariableTypeImpl extends TypeImpl implements TypeVariableType {
   /**
    * Return an array containing the type variable types defined by the given array of type variable
    * elements.
    * @param typeVariables the type variable elements defining the type variable types to be returned
    * @return the type variable types defined by the type variable elements
    */
   static List<TypeVariableType> getTypes(List<TypeVariableElement> typeVariables) {
     int count = typeVariables.length;
-    List<TypeVariableType> types = new List<TypeVariableType>.fixedLength(count);
+    List<TypeVariableType> types = new List<TypeVariableType>(count);
     for (int i = 0; i < count; i++) {
       types[i] = typeVariables[i].type;
     }
     return types;
   }
   /**
    * Initialize a newly created type variable to be declared by the given element and to have the
    * given name.
    * @param element the element representing the declaration of the type variable
    */
@@ skipping 325 matching lines @@
  * introduced by a type variable.
  */
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
-}
+}