Fix the dependencies for constant evaluation

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/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1538 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
 }
 
 /**
  * A task that computes [CONSTANT_DEPENDENCIES] for a constant.
  */
 class ComputeConstantDependenciesTask extends ConstantEvaluationAnalysisTask {
   /**
-   * The name of the [RESOLVED_UNIT9] input.
-   */
-  static const String UNIT_INPUT = 'UNIT_INPUT';
-
-  /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ComputeConstantDependenciesTask',
       createTask,
       buildInputs,
       <ResultDescriptor>[CONSTANT_DEPENDENCIES]);
 
   ComputeConstantDependenciesTask(
       InternalAnalysisContext context, ConstantEvaluationTarget constant)
       : super(context, constant);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
-    // Note: UNIT_INPUT is not needed.  It is merely a bookkeeping dependency
-    // to ensure that resolution has occurred before we attempt to determine
-    // constant dependencies.
-    //
     ConstantEvaluationTarget constant = target;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Compute dependencies.
     //
     List<ConstantEvaluationTarget> dependencies = <ConstantEvaluationTarget>[];
     new ConstantEvaluationEngine(typeProvider, context.declaredVariables,
             typeSystem: context.typeSystem)
         .computeDependencies(constant, dependencies.add);
     //
     // Record outputs.
     //
     outputs[CONSTANT_DEPENDENCIES] = 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
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    //
+    // We need to force the computation of the RESOLVED_UNIT9 for each unit
+    // reachable from the target's library so that all of the AST's for the
+    // contructor initializers that we might encounter have been copied into
+    // the element model.
+    //
+    // TODO(brianwilkerson) This could be improved by computing a more accurate
+    // list of the sources containing constructors that are actually referenced.
+    //
     if (target is Element) {
       CompilationUnitElementImpl unit = target
           .getAncestor((Element element) => element is CompilationUnitElement);
+      Source librarySource = unit.librarySource;
       return <String, TaskInput>{
-        UNIT_INPUT: RESOLVED_UNIT9
-            .of(new LibrarySpecificUnit(unit.librarySource, target.source)),
+        'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE.of(librarySource).toList(
+            (Source library) => UNITS.of(library).toList((Source source) =>
+                RESOLVED_UNIT9.of(new LibrarySpecificUnit(library, source)))),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     } else if (target is ConstantEvaluationTarget_Annotation) {
+      Source librarySource = target.librarySource;
       return <String, TaskInput>{
-        UNIT_INPUT: RESOLVED_UNIT9
-            .of(new LibrarySpecificUnit(target.librarySource, target.source)),
+        'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE.of(librarySource).toList(
+            (Source library) => UNITS.of(library).toList((Source source) =>
+                RESOLVED_UNIT9.of(new LibrarySpecificUnit(library, source)))),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     }
     throw new AnalysisException(
         'Cannot build inputs for a ${target.runtimeType}');
   }
 
   /**
    * Create a [ComputeConstantDependenciesTask] based on the given [target] in
    * the given [context].
@@ skipping 2286 matching lines @@
     // Resolve everything.
     //
     CompilationUnitElement unitElement = unit.element;
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ResolverVisitor visitor = new ResolverVisitor(
         libraryElement, unitElement.source, typeProvider, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
+    // TODO(brianwilkerson) This task modifies the element model (by copying the
+    // AST's for constructor initializers into it) but does not produce an
+    // updated version of the element model.
+    //
     outputs[RESOLVE_UNIT_ERRORS] = errorListener.errors;
     outputs[RESOLVED_UNIT9] = 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 given
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
@@ skipping 635 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }