Rename EMPTY_ARRAY to EMPTY_LIST in element model

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 3283 matching lines @@
   List<TopLevelVariableElement> _topLevelVariables;
 
   List<ClassElement> _types;
 
   List<FunctionTypeAliasElement> _typeAliases;
 
   List<TypeParameterElement> _typeParameters;
 
   List<PropertyAccessorElement> get accessors {
     if (_accessors == null) {
-      return PropertyAccessorElementImpl.EMPTY_ARRAY;
+      return PropertyAccessorElement.EMPTY_LIST;
     }
     List<PropertyAccessorElement> result = _accessors;
     _accessors = null;
     return result;
   }
 
   List<ConstructorElement> get constructors {
     if (_constructors == null) {
-      return ConstructorElementImpl.EMPTY_ARRAY;
+      return ConstructorElement.EMPTY_LIST;
     }
     List<ConstructorElement> result = _constructors;
     _constructors = null;
     return result;
   }
 
   List<ClassElement> get enums {
     if (_enums == null) {
-      return ClassElementImpl.EMPTY_ARRAY;
+      return ClassElement.EMPTY_LIST;
     }
     List<ClassElement> result = _enums;
     _enums = null;
     return result;
   }
 
   List<FieldElement> get fields {
     if (_fields == null) {
-      return FieldElementImpl.EMPTY_ARRAY;
+      return FieldElement.EMPTY_LIST;
     }
     List<FieldElement> result = _fields;
     _fields = null;
     return result;
   }
 
   List<FieldElement> get fieldsWithoutFlushing {
     if (_fields == null) {
-      return FieldElementImpl.EMPTY_ARRAY;
+      return FieldElement.EMPTY_LIST;
     }
     List<FieldElement> result = _fields;
     return result;
   }
 
   List<FunctionElement> get functions {
     if (_functions == null) {
-      return FunctionElementImpl.EMPTY_ARRAY;
+      return FunctionElement.EMPTY_LIST;
     }
     List<FunctionElement> result = _functions;
     _functions = null;
     return result;
   }
 
   List<LabelElement> get labels {
     if (_labels == null) {
-      return LabelElementImpl.EMPTY_ARRAY;
+      return LabelElement.EMPTY_LIST;
     }
     List<LabelElement> result = _labels;
     _labels = null;
     return result;
   }
 
   List<LocalVariableElement> get localVariables {
     if (_localVariables == null) {
-      return LocalVariableElementImpl.EMPTY_ARRAY;
+      return LocalVariableElement.EMPTY_LIST;
     }
     List<LocalVariableElement> result = _localVariables;
     _localVariables = null;
     return result;
   }
 
   List<MethodElement> get methods {
     if (_methods == null) {
-      return MethodElementImpl.EMPTY_ARRAY;
+      return MethodElement.EMPTY_LIST;
     }
     List<MethodElement> result = _methods;
     _methods = null;
     return result;
   }
 
   List<ParameterElement> get parameters {
     if (_parameters == null) {
-      return ParameterElementImpl.EMPTY_ARRAY;
+      return ParameterElement.EMPTY_LIST;
     }
     List<ParameterElement> result = _parameters;
     _parameters = null;
     return result;
   }
 
   List<TopLevelVariableElement> get topLevelVariables {
     if (_topLevelVariables == null) {
-      return TopLevelVariableElementImpl.EMPTY_ARRAY;
+      return TopLevelVariableElement.EMPTY_LIST;
     }
     List<TopLevelVariableElement> result = _topLevelVariables;
     _topLevelVariables = null;
     return result;
   }
 
   List<FunctionTypeAliasElement> get typeAliases {
     if (_typeAliases == null) {
-      return FunctionTypeAliasElementImpl.EMPTY_ARRAY;
+      return FunctionTypeAliasElement.EMPTY_LIST;
     }
     List<FunctionTypeAliasElement> result = _typeAliases;
     _typeAliases = null;
     return result;
   }
 
   List<TypeParameterElement> get typeParameters {
     if (_typeParameters == null) {
-      return TypeParameterElementImpl.EMPTY_ARRAY;
+      return TypeParameterElement.EMPTY_LIST;
     }
     List<TypeParameterElement> result = _typeParameters;
     _typeParameters = null;
     return result;
   }
 
   List<ClassElement> get types {
     if (_types == null) {
-      return ClassElementImpl.EMPTY_ARRAY;
+      return ClassElement.EMPTY_LIST;
     }
     List<ClassElement> result = _types;
     _types = null;
     return result;
   }
 
   void addAccessor(PropertyAccessorElement element) {
     if (_accessors == null) {
       _accessors = new List<PropertyAccessorElement>();
     }
@@ skipping 11087 matching lines @@
    *
    * @param type the type whole type arguments are to be returned
    * @return the type arguments associated with the given type
    */
   List<DartType> _getTypeArguments(DartType type) {
     if (type is InterfaceType) {
       return type.typeArguments;
     } else if (type is FunctionType) {
       return type.typeArguments;
     }
-    return TypeImpl.EMPTY_ARRAY;
+    return DartType.EMPTY_LIST;
   }
 
   /**
    * Returns the simple identifier of the given (may be qualified) type name.
    *
    * @param typeName the (may be qualified) qualified type name
    * @return the simple identifier of the given (may be qualified) type name.
    */
   SimpleIdentifier _getTypeSimpleIdentifier(Identifier typeName) {
     if (typeName is SimpleIdentifier) {
@@ skipping 271 matching lines @@
       FunctionTypeAliasElement alias =
           element.getAncestor((element) => element is FunctionTypeAliasElement);
       while (alias != null && alias.isSynthetic) {
         alias =
             alias.getAncestor((element) => element is FunctionTypeAliasElement);
       }
       if (alias != null) {
         aliasElement.typeParameters = alias.typeParameters;
         type.typeArguments = alias.type.typeArguments;
       } else {
-        type.typeArguments = TypeImpl.EMPTY_ARRAY;
+        type.typeArguments = DartType.EMPTY_LIST;
       }
     }
     element.type = type;
   }
 
   /**
    * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
   static bool _isBuiltInIdentifier(TypeName node) {
     sc.Token token = node.name.beginToken;
@@ skipping 580 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }