Replace some LIBRARY_ELEMENTx dependency for closure with READY_LIBRARY_ELEMENTx.

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 329 matching lines @@
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
 final ListResultDescriptor<AnalysisError> PARSE_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'PARSE_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
+ * The flag specifying that [LIBRARY_ELEMENT2] is ready for a library.

[Brian Wilkerson, 2015/10/23 21:50:55]

Maybe include a longer explanation here like the one in the task class docs: "is
ready for every unit of a library".

+ *
+ * The result is only available for [Source]s representing a library.
+ */
+final ResultDescriptor<bool> READY_LIBRARY_ELEMENT2 =
+    new ResultDescriptor<bool>('READY_LIBRARY_ELEMENT2', false);
+
+/**
+ * The flag specifying that [LIBRARY_ELEMENT5] is ready for a library.
+ *
+ * The result is only available for [Source]s representing a library.
+ */
+final ResultDescriptor<bool> READY_LIBRARY_ELEMENT5 =
+    new ResultDescriptor<bool>('READY_LIBRARY_ELEMENT5', false);
+
+/**
  * The flag specifying that [RESOLVED_UNIT] is ready for a library.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<bool> READY_RESOLVED_UNIT =
     new ResultDescriptor<bool>('READY_RESOLVED_UNIT', false);
 
 /**
  * The flag specifying that [RESOLVED_UNIT10] is ready for a library.
  *
@@ skipping 1576 matching lines @@
   }
 
   /**
    * 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) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      'resolveReachableLibraries': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(unit.library)
-          .toListOf(LIBRARY_ELEMENT2),
-      LIBRARY_ELEMENT_INPUT: LIBRARY_ELEMENT2.of(unit.library)
+      LIBRARY_ELEMENT_INPUT: LIBRARY_ELEMENT2.of(unit.library),
+      'resolveReachableLibraries': READY_LIBRARY_ELEMENT2.of(unit.library),
     };
   }
 
   /**
    * Create a [ComputeLibraryCycleTask] based on the
    * given [target] in the given [context].
    */
   static ComputeLibraryCycleTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeLibraryCycleTask(context, target);
@@ skipping 1511 matching lines @@
   }
 
   /**
    * 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) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      'fullyBuiltLibraryElements': IMPORT_EXPORT_SOURCE_CLOSURE
-          .of(unit.library)
-          .toListOf(LIBRARY_ELEMENT5),
+      '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_UNIT8
@@ skipping 44 matching lines @@
   void _addPublicNames(CompilationUnitElement compilationUnit) {
     compilationUnit.accessors.forEach(_addIfPublic);
     compilationUnit.enums.forEach(_addIfPublic);
     compilationUnit.functions.forEach(_addIfPublic);
     compilationUnit.functionTypeAliases.forEach(_addIfPublic);
     compilationUnit.types.forEach(_addIfPublic);
   }
 }
 
 /**
+ * A task that ensures that [LIBRARY_ELEMENT2] is ready for every unit of the
+ * target library source and its import/export closure.
+ */
+class ReadyLibraryElement2Task extends SourceBasedAnalysisTask {
+  static const String IS_CLIENT_LIST_INPUT1 = 'IS_CLIENT_LIST_INPUT1';
+  static const String IS_CLIENT_LIST_INPUT2 = 'IS_CLIENT_LIST_INPUT2';
+
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ReadyLibraryElement2Task',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[READY_LIBRARY_ELEMENT2, IS_CLIENT]);
+
+  ReadyLibraryElement2Task(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  bool get handlesDependencyCycles => true;
+
+  @override
+  void internalPerform() {
+    bool isClient = _isClient();
+    outputs[READY_LIBRARY_ELEMENT2] = true;
+    outputs[IS_CLIENT] = isClient;
+  }
+
+  bool _isClient() {
+    Source htmlSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
+    Source source = getRequiredSource();
+    if (source == htmlSource) {
+      return true;
+    }
+    if (_hasTrueElement(getRequiredInput(IS_CLIENT_LIST_INPUT1))) {
+      return true;
+    }
+    if (_hasTrueElement(getRequiredInput(IS_CLIENT_LIST_INPUT2))) {
+      return true;
+    }
+    return false;
+  }
+
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
+    return <String, TaskInput>{
+      'thisLibraryElementReady': LIBRARY_ELEMENT2.of(source),
+      IS_CLIENT_LIST_INPUT1: IMPORTED_LIBRARIES.of(source).toListOf(IS_CLIENT),
+      IS_CLIENT_LIST_INPUT2: EXPORTED_LIBRARIES.of(source).toListOf(IS_CLIENT),
+      'directlyImportedLibrariesReady':
+          IMPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT2),
+      'directlyExportedLibrariesReady':
+          EXPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT2),
+    };
+  }
+
+  static ReadyLibraryElement2Task createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ReadyLibraryElement2Task(context, target);
+  }
+
+  static bool _hasTrueElement(List<bool> elements) {
+    if (elements != null) {
+      for (bool isClient in elements) {
+        if (isClient == true) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * A task that ensures that [LIBRARY_ELEMENT5] is ready for every unit of the
+ * target library source and its import/export closure.
+ */
+class ReadyLibraryElement5Task extends SourceBasedAnalysisTask {
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ReadyLibraryElement5Task',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[READY_LIBRARY_ELEMENT5]);
+
+  ReadyLibraryElement5Task(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  bool get handlesDependencyCycles => true;
+
+  @override
+  void internalPerform() {
+    outputs[READY_LIBRARY_ELEMENT5] = true;
+  }
+
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    Source source = target;
+    return <String, TaskInput>{
+      'thisLibraryElementReady': LIBRARY_ELEMENT5.of(source),
+      'directlyImportedLibrariesReady':
+          IMPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT5),
+      'directlyExportedLibrariesReady':
+          EXPORTED_LIBRARIES.of(source).toListOf(READY_LIBRARY_ELEMENT5),
+    };
+  }
+
+  static ReadyLibraryElement5Task createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ReadyLibraryElement5Task(context, target);
+  }
+}
+
+/**
  * A task that ensures that [RESOLVED_UNIT10] is ready for every unit of the
  * target library source and its import/export closure.
  */
 class ReadyResolvedUnit10Task extends SourceBasedAnalysisTask {
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ReadyResolvedUnit10Task',
       createTask,
       buildInputs,
       <ResultDescriptor>[READY_RESOLVED_UNIT10]);
 
@@ skipping 398 matching lines @@
    * Create a [ResolveLibraryReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveLibraryReferencesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryReferencesTask(context, target);
   }
 }
 
 /**
- * An artifitial task that does nothing except to force type names resolution
+ * An artificial task that does nothing except to force type names resolution
  * for the defining and part units of a library.
  */
 class ResolveLibraryTypeNamesTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [LIBRARY_ELEMENT4] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
@@ skipping 760 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }