Use READY_RESOLVED_UNIT flag for ordering tasks.

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/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 2928 matching lines @@
       // ordering.
 
       // Require that field re-resolution be complete for all units in the
       // current library cycle.
       'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit).toList(
           (CompilationUnitElementImpl unit) => RESOLVED_UNIT8
               .of(new LibrarySpecificUnit(unit.librarySource, unit.source))),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit).toList(
-          (CompilationUnitElementImpl unit) => RESOLVED_UNIT9
-              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
+          (CompilationUnitElementImpl unit) =>
+              READY_RESOLVED_UNIT.of(unit.librarySource))

[Brian Wilkerson, 2015/12/18 18:52:19]

I'm a little concerned by the specifics of this change. I like the general idea
a lot, but I'm concerned because READY_RESOLVED_UNIT implies a lot more analysis
(such as constant evaluation) than RESOLVED_UNIT9 did. Even assuming that we can
safely perform that extra analysis at this point without creating a cycle in the
dependency graph (which I haven't convinced myself of), I'd like to (a) do less
work rather than more and (b) remember the real dependencies so that it's clear
in the future what can and cannot change in terms of the task structure.

Perhaps we could define a result (named something like CREATED_RESOLVED_UNIT9)
that gets created by the same task that creates RESOLVED_UNIT9, and then we
could depend on that flag here. The flag would have the semantics that we know
that the work of creating a RESOLVED_UNIT9 had been done, whether the result was
still in the cache or not.

     };
   }
 
   /**
    * 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 218 matching lines @@
           .of(variable)
           .toListOf(INFERRED_STATIC_VARIABLE),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       UNIT_INPUT: RESOLVED_UNIT6.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).toList(
-          (CompilationUnitElementImpl unit) => RESOLVED_UNIT9
-              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
+          (CompilationUnitElementImpl unit) =>
+              READY_RESOLVED_UNIT.of(unit.librarySource))
     };
   }
 
   /**
    * 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 446 matching lines @@
       'fullyBuiltLibraryElements': READY_LIBRARY_ELEMENT5.of(unit.library),
       LIBRARY_INPUT: LIBRARY_ELEMENT5.of(unit.library),
       UNIT_INPUT: RESOLVED_UNIT4.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).toList(
-          (CompilationUnitElementImpl unit) => RESOLVED_UNIT9
-              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
+          (CompilationUnitElementImpl unit) =>
+              READY_RESOLVED_UNIT.of(unit.librarySource))
     };
   }
 
   /**
    * 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 763 matching lines @@
       // ordering.
 
       // Require that static variable inference  be complete for all units in
       // the current library cycle.
       'orderLibraryCycleTasks': LIBRARY_CYCLE_UNITS.of(unit).toList(
           (CompilationUnitElementImpl unit) => RESOLVED_UNIT7
               .of(new LibrarySpecificUnit(unit.librarySource, unit.source))),
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES.of(unit).toList(
-          (CompilationUnitElementImpl unit) => RESOLVED_UNIT9
-              .of(new LibrarySpecificUnit(unit.librarySource, unit.source)))
+          (CompilationUnitElementImpl unit) =>
+              READY_RESOLVED_UNIT.of(unit.librarySource))
     };
   }
 
   /**
    * 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 640 matching lines @@
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     if (context.analysisOptions.strongMode) {
       unit.accept(new CodeChecker(
           typeProvider, new StrongTypeSystemImpl(), errorListener));
     }
-
     //
     // Record outputs.
     //
     outputs[STRONG_MODE_ERRORS] = getUniqueErrors(errorListener.errors);
     outputs[RESOLVED_UNIT] = unit;
   }
 
   /**
    * 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 243 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }