Rename EMPTY_ARRAY to EMPTY_LIST

pkg/analyzer/lib/src/context/context.dart

 // Copyright (c) 2015, 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 analyzer.src.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
@@ skipping 215 matching lines @@
     this._options.lint = options.lint;
     this._options.preserveComments = options.preserveComments;
     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;
       } else {
         _priorityOrder = sources;
       }
     }
   }
 
   @override
   set contentCache(ContentCache value) {
     _contentCache = value;
   }
@@ skipping 516 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<AnalysisTarget, cache.CacheEntry> iterator =
             _cache.iterator();
         while (iterator.moveNext()) {
           cache.CacheEntry entry = iterator.value;
           if (entry.getValue(SOURCE_KIND) == SourceKind.HTML) {
@@ skipping 14 matching lines @@
                 (entry as HtmlEntry).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) => _getResult(source, SOURCE_KIND);
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     // TODO(brianwilkerson) Implement this.
 //    cache.CacheEntry sourceEntry = _cache.get(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<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       cache.CacheEntry entry = iterator.value;
       if (entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY) {
         if (_contains(entry.getValue(EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(iterator.key);
         }
         if (_contains(entry.getValue(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) {
     // TODO(brianwilkerson) Implement this.
 //    cache.CacheEntry entry = getReadableSourceEntryOrNull(htmlSource);
 //    if (entry is HtmlEntry) {
 //      HtmlEntry htmlEntry = entry;
 //      return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
 //    }
-    return Source.EMPTY_ARRAY;
+    return Source.EMPTY_LIST;
   }
 
   @override
   LibraryElement getLibraryElement(Source source) =>
       _getResult(source, LIBRARY_ELEMENT);
 
   @override
   LineInfo getLineInfo(Source source) => _getResult(source, LINE_INFO);
 
   @override
@@ skipping 199 matching lines @@
         entry.setValue(result, value, cache.TargetedResult.EMPTY_LIST, null);
       }
       setValue(BUILD_DIRECTIVES_ERRORS, AnalysisError.NO_ERRORS);
       setValue(BUILD_FUNCTION_TYPE_ALIASES_ERRORS, AnalysisError.NO_ERRORS);
       setValue(BUILD_LIBRARY_ERRORS, AnalysisError.NO_ERRORS);
       // CLASS_ELEMENTS
       setValue(COMPILATION_UNIT_ELEMENT, library.definingCompilationUnit);
       // CONSTRUCTORS
       // CONSTRUCTORS_ERRORS
       entry.setState(CONTENT, CacheState.FLUSHED);
-      setValue(EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      setValue(EXPORTED_LIBRARIES, Source.EMPTY_LIST);
       // EXPORT_SOURCE_CLOSURE
-      setValue(IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      setValue(IMPORTED_LIBRARIES, Source.EMPTY_LIST);
       // IMPORT_SOURCE_CLOSURE
-      setValue(INCLUDED_PARTS, Source.EMPTY_ARRAY);
+      setValue(INCLUDED_PARTS, Source.EMPTY_LIST);
       setValue(IS_CLIENT, true);
       setValue(IS_LAUNCHABLE, false);
       setValue(LIBRARY_ELEMENT, library);
       setValue(LIBRARY_ELEMENT1, library);
       setValue(LIBRARY_ELEMENT2, library);
       setValue(LIBRARY_ELEMENT3, library);
       setValue(LIBRARY_ELEMENT4, library);
       setValue(LIBRARY_ELEMENT5, library);
       setValue(LINE_INFO, new LineInfo(<int>[0]));
       setValue(PARSE_ERRORS, AnalysisError.NO_ERRORS);
@@ skipping 1045 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }