Make LIBRARY_CYCLE_UNITS and LIBRARY_CYCLE_DEPENDENCIES be List<LibrarySpecificUnit>.

pkg/analyzer/lib/src/task/dart.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.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 399 matching lines @@
  * component in the import/export graph in which the target resides.
  *
  * Only non-empty in strongMode.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ListResultDescriptor<LibraryElement> LIBRARY_CYCLE =
     new ListResultDescriptor<LibraryElement>('LIBRARY_CYCLE', null);
 
 /**
- * A list of the [CompilationUnitElement]s that comprise all of the parts and
+ * A list of the [LibrarySpecificUnit]s that comprise all of the parts and
  * libraries in the direct import/export dependencies of the library cycle
  * of the target, with the intra-component dependencies excluded.
  *
  * Only non-empty in strongMode.
  *
  * The result is only available for [Source]s representing a library.
  */
-final ListResultDescriptor<CompilationUnitElement> LIBRARY_CYCLE_DEPENDENCIES =
-    new ListResultDescriptor<CompilationUnitElement>(
+final ListResultDescriptor<LibrarySpecificUnit> LIBRARY_CYCLE_DEPENDENCIES =
+    new ListResultDescriptor<LibrarySpecificUnit>(
         'LIBRARY_CYCLE_DEPENDENCIES', null);
 
 /**
- * A list of the [CompilationUnitElement]s (including all parts) that make up
+ * A list of the [LibrarySpecificUnit]s (including all parts) that make up
  * the strongly connected component in the import/export graph in which the
  * target resides.
  *
  * Only non-empty in strongMode.
  *
  * The result is only available for [Source]s representing a library.
  */
-final ListResultDescriptor<CompilationUnitElement> LIBRARY_CYCLE_UNITS =
-    new ListResultDescriptor<CompilationUnitElement>(
-        'LIBRARY_CYCLE_UNITS', null);
+final ListResultDescriptor<LibrarySpecificUnit> LIBRARY_CYCLE_UNITS =
+    new ListResultDescriptor<LibrarySpecificUnit>('LIBRARY_CYCLE_UNITS', null);
 
 /**
  * The partial [LibraryElement] associated with a library.
  *
  * The [LibraryElement] and its [CompilationUnitElement]s are attached to each
  * other. Directives 'library', 'part' and 'part of' are resolved.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT1 =
@@ skipping 1738 matching lines @@
     // from a node is changed, its LIBRARY_CYCLE results will be re-computed
     // here (possibly re-using the result from the element model if invalidation
     // did not cause it to be erased).  In summary, task model dependencies
     // on the import/export source closure ensure that this method will be
     // re-run if anything reachable from this target has been invalidated,
     // and the invalidation code (invalidateLibraryCycles) will ensure that
     // element model results will be re-used here only if they are still valid.
     if (context.analysisOptions.strongMode) {
       LibraryElement library = getRequiredInput(LIBRARY_ELEMENT_INPUT);
       List<LibraryElement> component = library.libraryCycle;
-      Set<LibraryElement> filter = new Set<LibraryElement>.from(component);
+      Set<LibraryElement> filter = component.toSet();
       Set<CompilationUnitElement> deps = new Set<CompilationUnitElement>();
       void addLibrary(LibraryElement l) {
         if (!filter.contains(l)) {
           deps.addAll(l.units);
         }
       }
 
       int length = component.length;
       for (int i = 0; i < length; i++) {
         LibraryElement library = component[i];
         library.importedLibraries.forEach(addLibrary);
         library.exportedLibraries.forEach(addLibrary);
       }
       //
       // Record outputs.
       //
+      LibrarySpecificUnit unitToLSU(CompilationUnitElement unit) =>
+          new LibrarySpecificUnit(unit.librarySource, unit.source);
       outputs[LIBRARY_CYCLE] = component;
-      outputs[LIBRARY_CYCLE_UNITS] = component.expand((l) => l.units).toList();
-      outputs[LIBRARY_CYCLE_DEPENDENCIES] = deps.toList();
+      outputs[LIBRARY_CYCLE_UNITS] =
+          component.expand((l) => l.units).map(unitToLSU).toList();
+      outputs[LIBRARY_CYCLE_DEPENDENCIES] = deps.map(unitToLSU).toList();
     } else {
       outputs[LIBRARY_CYCLE] = [];
       outputs[LIBRARY_CYCLE_UNITS] = [];
       outputs[LIBRARY_CYCLE_DEPENDENCIES] = [];
     }
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
@@ skipping 1189 matching lines @@
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       UNIT_INPUT: RESOLVED_UNIT9.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that field re-resolution be complete for all units in the
       // current library cycle.
-      'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT9.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source))),
+      'orderLibraryCycleTasks':
+          LIBRARY_CYCLE_UNITS.of(unit.library).toListOf(CREATED_RESOLVED_UNIT9),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
-      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source)))
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES
+          .of(unit.library)
+          .toListOf(CREATED_RESOLVED_UNIT10)
     };
   }
 
   /**
    * Create a [InferInstanceMembersInUnitTask] based on the given [target] in
    * the given [context].
    */
   static InferInstanceMembersInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new InferInstanceMembersInUnitTask(context, target);
@@ skipping 262 matching lines @@
       DEPENDENCIES_INPUT: INFERABLE_STATIC_VARIABLE_DEPENDENCIES
           .of(variable)
           .toListOf(INFERRED_STATIC_VARIABLE),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       UNIT_INPUT: RESOLVED_UNIT7.of(unit),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
-      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source)))
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES
+          .of(unit.library)
+          .toListOf(CREATED_RESOLVED_UNIT10)
     };
   }
 
   /**
    * Create a [InferStaticVariableTypeTask] based on the given [target] in the
    * given [context].
    */
   static InferStaticVariableTypeTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new InferStaticVariableTypeTask(context, target);
@@ skipping 491 matching lines @@
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': READY_LIBRARY_ELEMENT6.of(unit.library),
       LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
       UNIT_INPUT: RESOLVED_UNIT6.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
-      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source)))
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES
+          .of(unit.library)
+          .toListOf(CREATED_RESOLVED_UNIT10)
     };
   }
 
   /**
    * Create a [PartiallyResolveUnitReferencesTask] based on the given [target]
    * in the given [context].
    */
   static PartiallyResolveUnitReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new PartiallyResolveUnitReferencesTask(context, target);
@@ skipping 892 matching lines @@
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       UNIT_INPUT: RESOLVED_UNIT8.of(unit),
       LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that static variable inference  be complete for all units in
       // the current library cycle.
-      'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT8.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source))),
+      'orderLibraryCycleTasks':
+          LIBRARY_CYCLE_UNITS.of(unit.library).toListOf(CREATED_RESOLVED_UNIT8),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
-      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source)))
+      'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES
+          .of(unit.library)
+          .toListOf(CREATED_RESOLVED_UNIT10)
     };
   }
 
   /**
    * Create a [ResolveInstanceFieldsInUnitTask] based on the given [target] in
    * the given [context].
    */
   static ResolveInstanceFieldsInUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveInstanceFieldsInUnitTask(context, target);
@@ skipping 435 matching lines @@
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT8.of(unit.library),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       UNIT_INPUT: RESOLVED_UNIT10.of(unit),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that inference be complete for all units in the
       // current library cycle.
-      'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit.library).toList(
-          (CompilationUnitElement unit) => CREATED_RESOLVED_UNIT10.of(
-              new LibrarySpecificUnit(
-                  (unit as CompilationUnitElementImpl).librarySource,
-                  unit.source)))
+      'orderLibraryCycleTasks':
+          LIBRARY_CYCLE_UNITS.of(unit.library).toListOf(CREATED_RESOLVED_UNIT10)
     };
   }
 
   /**
    * Create a [ResolveUnitTask] based on the given [target] in
    * the given [context].
    */
   static ResolveUnitTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveUnitTask(context, target);
@@ skipping 719 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }