Rename EMPTY_ARRAY to EMPTY_LIST

pkg/analyzer/lib/src/generated/engine.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;
 
 import "dart:math" as math;
@@ skipping 901 matching lines @@
 
   /**
    * A table mapping the sources known to the context to the information known
    * about the source.
    */
   AnalysisCache _cache;
 
   /**
    * A list containing sources for which data should not be flushed.
    */
-  List<Source> _priorityOrder = Source.EMPTY_ARRAY;
+  List<Source> _priorityOrder = Source.EMPTY_LIST;
 
   /**
    * A map from all sources for which there are futures pending to a list of
    * the corresponding PendingFuture objects.  These sources will be analyzed
    * in the same way as priority sources, except with higher priority.
    *
    * TODO(paulberry): since the size of this map is not constrained (as it is
    * for _priorityOrder), we run the risk of creating an analysis loop if
    * re-caching one AST structure causes the AST structure for another source
    * with pending futures to be flushed.  However, this is unlikely to happen
@@ skipping 150 matching lines @@
     _generateImplicitErrors = options.generateImplicitErrors;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllLocalResolutionInformation(false);
     }
   }
 
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
-      _priorityOrder = Source.EMPTY_ARRAY;
+      _priorityOrder = Source.EMPTY_LIST;
     } else {
       while (sources.remove(null)) {
         // Nothing else to do.
       }
       if (sources.isEmpty) {
-        _priorityOrder = Source.EMPTY_ARRAY;
+        _priorityOrder = Source.EMPTY_LIST;
       }
       //
       // Cap the size of the priority list to being less than the cache size.
       // Failure to do so can result in an infinite loop in
       // performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int count = math.min(
           sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
       _priorityOrder = new List<Source>(count);
@@ skipping 522 matching lines @@
         AnalysisEngine.instance.logger.logInformation(
             "Could not compute errors",
             new CaughtException(exception, stackTrace));
       }
     }
     return AnalysisError.NO_ERRORS;
   }
 
   @override
   List<Source> computeExportedLibraries(Source source) => _getDartParseData2(
-      source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_LIST);
 
   @override
   HtmlElement computeHtmlElement(Source source) =>
       _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
   @override
   List<Source> computeImportedLibraries(Source source) => _getDartParseData2(
-      source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_LIST);
 
   @override
   SourceKind computeKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
         return _getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException {
@@ skipping 251 matching lines @@
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   @override
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
         MapIterator<Source, SourceEntry> partIterator = _cache.iterator();
         while (partIterator.moveNext()) {
           SourceEntry sourceEntry = partIterator.value;
           if (sourceEntry.kind == SourceKind.HTML) {
             List<Source> referencedLibraries = (sourceEntry as HtmlEntry)
@@ skipping 12 matching lines @@
                 .getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_contains(referencedLibraries, source)) {
               htmlSources.add(iterator.key);
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     return htmlSources;
   }
 
   @override
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.containingLibraries;
     }
-    return Source.EMPTY_ARRAY;
+    return Source.EMPTY_LIST;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY) {
         if (_contains(
             (sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES),
             librarySource)) {
           dependentLibraries.add(iterator.key);
         }
         if (_contains(
             (sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES),
             librarySource)) {
           dependentLibraries.add(iterator.key);
         }
       }
     }
     if (dependentLibraries.isEmpty) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     return dependentLibraries;
   }
 
   @override
   List<Source> getLibrariesReferencedFromHtml(Source htmlSource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
     }
-    return Source.EMPTY_ARRAY;
+    return Source.EMPTY_LIST;
   }
 
   @override
   LibraryElement getLibraryElement(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
@@ skipping 273 matching lines @@
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         _recordElementData(dartEntry, library, library.source, htmlSource);
         dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
         dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
         // DartEntry.ELEMENT - set in recordElementData
-        dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
-        dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
-        dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
+        dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_LIST);
+        dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_LIST);
+        dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_LIST);
         // DartEntry.IS_CLIENT - set in recordElementData
         // DartEntry.IS_LAUNCHABLE - set in recordElementData
         dartEntry.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
         dartEntry.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED);
         dartEntry.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
         dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
         dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource,
             AnalysisError.NO_ERRORS);
@@ skipping 3023 matching lines @@
     }
     return sources;
   }
 
   /**
    * Return the sources described by the given [descriptor].
    */
   List<Source> _getSources(Source source, DartEntry dartEntry,
       DataDescriptor<List<Source>> descriptor) {
     if (dartEntry == null) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     CacheState exportState = dartEntry.getState(descriptor);
     if (exportState == CacheState.ERROR) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     } else if (exportState != CacheState.VALID) {
       if (_taskData == null) {
         _taskData =
             AnalysisContextImpl_this._createParseDartTask(source, dartEntry);
       }
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     return dartEntry.getValue(descriptor);
   }
 }
 
 /**
  * Information about the next task to be performed. Each data has an implicit
  * associated source: the source that might need to be analyzed. There are
  * essentially three states that can be represented:
  *
@@ skipping 1874 matching lines @@
    */
   static final DataDescriptor<CompilationUnit> BUILT_UNIT =
       new DataDescriptor<CompilationUnit>("DartEntry.BUILT_UNIT");
 
   /**
    * The data descriptor representing the list of libraries that contain this
    * compilation unit.
    */
   static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.CONTAINING_LIBRARIES", Source.EMPTY_ARRAY);
+          "DartEntry.CONTAINING_LIBRARIES", Source.EMPTY_LIST);
 
   /**
    * The data descriptor representing the library element for the library. This
    * data is only available for Dart files that are the defining compilation
    * unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT =
       new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
   /**
    * The data descriptor representing the list of exported libraries. This data
    * is only available for Dart files that are the defining compilation unit of
    * a library.
    */
   static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.EXPORTED_LIBRARIES", Source.EMPTY_ARRAY);
+          "DartEntry.EXPORTED_LIBRARIES", Source.EMPTY_LIST);
 
   /**
    * The data descriptor representing the hints resulting from auditing the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> HINTS =
       new DataDescriptor<List<AnalysisError>>(
           "DartEntry.HINTS", AnalysisError.NO_ERRORS);
 
   /**
    * The data descriptor representing the list of imported libraries. This data
    * is only available for Dart files that are the defining compilation unit of
    * a library.
    */
   static final DataDescriptor<List<Source>> IMPORTED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "DartEntry.IMPORTED_LIBRARIES", Source.EMPTY_ARRAY);
+          "DartEntry.IMPORTED_LIBRARIES", Source.EMPTY_LIST);
 
   /**
    * The data descriptor representing the list of included parts. This data is
    * only available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<List<Source>> INCLUDED_PARTS =
       new DataDescriptor<List<Source>>(
-          "DartEntry.INCLUDED_PARTS", Source.EMPTY_ARRAY);
+          "DartEntry.INCLUDED_PARTS", Source.EMPTY_LIST);
 
   /**
    * The data descriptor representing the client flag. This data is only
    * available for Dart files that are the defining compilation unit of a
    * library.
    */
   static final DataDescriptor<bool> IS_CLIENT =
       new DataDescriptor<bool>("DartEntry.IS_CLIENT", false);
 
   /**
@@ skipping 1231 matching lines @@
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<ht.HtmlUnit> RESOLVED_UNIT =
       new DataDescriptor<ht.HtmlUnit>("HtmlEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the list of referenced libraries.
    */
   static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES =
       new DataDescriptor<List<Source>>(
-          "HtmlEntry.REFERENCED_LIBRARIES", Source.EMPTY_ARRAY);
+          "HtmlEntry.REFERENCED_LIBRARIES", Source.EMPTY_LIST);
 
   /**
    * The data descriptor representing the errors resulting from resolving the
    * source.
    */
   static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS =
       new DataDescriptor<List<AnalysisError>>(
           "HtmlEntry.RESOLUTION_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
@@ skipping 859 matching lines @@
       _errors = errorListener.getErrorsForSource(source);
     });
   }
 
   /**
    * Efficiently convert the given set of [sources] to a list.
    */
   List<Source> _toArray(HashSet<Source> sources) {
     int size = sources.length;
     if (size == 0) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     return new List.from(sources);
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param context the context in which the resolution is to be performed
    * @param librarySource the source representing the library containing the directive
@@ skipping 76 matching lines @@
   ht.HtmlUnit _unit;
 
   /**
    * The errors that were produced by scanning and parsing the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * A list containing the sources of the libraries that are referenced within the HTML.
    */
-  List<Source> _referencedLibraries = Source.EMPTY_ARRAY;
+  List<Source> _referencedLibraries = Source.EMPTY_LIST;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param content the contents of the source
    */
   ParseHtmlTask(InternalAnalysisContext context, this.source, this._content)
       : super(context);
@@ skipping 15 matching lines @@
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
     _unit.accept(new ParseHtmlTask_getLibrarySources(this, libraries));
     if (libraries.isEmpty) {
-      return Source.EMPTY_ARRAY;
+      return Source.EMPTY_LIST;
     }
     return libraries;
   }
 
   /**
    * Return the line information that was produced, or `null` if the task has not yet been
    * performed or if an exception occurred.
    *
    * @return the line information that was produced
    */
@@ skipping 2126 matching lines @@
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {}