Task: Build Export Source Closure.

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/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 31 matching lines @@
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for targets representing a Dart library.
  */
 final ResultDescriptor<List<AnalysisError>> BUILD_LIBRARY_ERRORS =
     new ResultDescriptor<List<AnalysisError>>(
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS,
         contributesTo: ANALYSIS_ERRORS);
 
 /**
+ * The sources representing the export closure of a library.
+ *
+ * The result is only available for targets representing a Dart library.
+ */
+final ResultDescriptor<List<Source>> EXPORT_SOURCE_CLOSURE =
+    new ResultDescriptor<List<Source>>('EXPORT_SOURCE_CLOSURE', 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 targets representing a Dart library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT1 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT1', null);
 
 /**
+ * The partial [LibraryElement] associated with a library.
+ *
+ * In addition to [LIBRARY_ELEMENT1] `imports` and `exports` of the
+ * [LibraryElement] are set.
+ *
+ * The result is only available for targets representing a Dart library.
+ */
+final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT2 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT2', null);
+
+/**
  * The partially resolved [CompilationUnit] associated with a unit.
  *
  * All declarations bound to the element defined by the declaration.
  *
  * The result is only available for targets representing a unit.
  */
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT1 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT1', null);
 
 /**
@@ skipping 100 matching lines @@
    * Create a [BuildCompilationUnitElementTask] based on the given [target] in
    * the given [context].
    */
   static BuildCompilationUnitElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildCompilationUnitElementTask(context, target);
   }
 }
 
 /**
- * A task that builds [RESOLVED_UNIT3] for a library.
+ * A task that builds imports and export directive elements for a library.
  */
 class BuildDirectiveElementsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input for [RESOLVED_UNIT2] of a library unit.
    */
   static const String RESOLVED_UNIT2_INPUT_NAME = 'RESOLVED_UNIT2_INPUT_NAME';
 
   /**
    * The input with a list of [LIBRARY_ELEMENT1]s of imported libraries.
    */
@@ skipping 16 matching lines @@
    * The input with a list of [SOURCE_KIND]s of exported libraries.
    */
   static const String EXPORTS_SOURCE_KIND_INPUT_NAME =
       'EXPORTS_SOURCE_KIND_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BUILD_RESOLVED_UNIT3', createTask, buildInputs, <ResultDescriptor>[
+    LIBRARY_ELEMENT2,
     RESOLVED_UNIT3,
     BUILD_DIRECTIVES_ERRORS
   ]);
 
   BuildDirectiveElementsTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
@@ skipping 124 matching lines @@
 //      Namespace namespace = new NamespaceBuilder()
 //          .createExportNamespaceForLibrary(libraryElement);
 //      Element element = namespace.get(FunctionElement.MAIN_FUNCTION_NAME);
 //      if (element is FunctionElement) {
 //        libraryElement.entryPoint = element;
 //      }
 //    }
     //
     // Record outputs.
     //
+    outputs[LIBRARY_ELEMENT2] = libraryElement;
     outputs[RESOLVED_UNIT3] = libraryUnit;
     outputs[BUILD_DIRECTIVES_ERRORS] = errors;
   }
 
   /**
    * 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 library [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
@@ skipping 119 matching lines @@
    * Create a [BuildEnumMemberElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildEnumMemberElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildEnumMemberElementsTask(context, target);
   }
 }
 
 /**
+ * A task that builds [EXPORT_SOURCE_CLOSURE] of a library.
+ */
+class BuildExportSourceClosureTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the input for [LIBRARY_ELEMENT2] of a library.
+   */
+  static const String LIBRARY2_ELEMENT_INPUT = 'LIBRARY2_ELEMENT_INPUT';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'BuildExportSourceClosureTask', createTask, buildInputs,
+      <ResultDescriptor>[EXPORT_SOURCE_CLOSURE]);
+
+  BuildExportSourceClosureTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    LibraryElement library = getRequiredInput(LIBRARY2_ELEMENT_INPUT);
+    //
+    // Compute export closure.
+    //
+    Set<LibraryElement> libraries = new Set<LibraryElement>();
+    _buildExportClosure(libraries, library);
+    List<Source> sources = libraries.map((lib) => lib.source).toList();
+    //
+    // Record outputs.
+    //
+    outputs[EXPORT_SOURCE_CLOSURE] = sources;
+  }
+
+  /**
+   * 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 library [source].
+   */
+  static Map<String, TaskInput> buildInputs(Source source) {
+    return <String, TaskInput>{
+      LIBRARY2_ELEMENT_INPUT: LIBRARY_ELEMENT2.inputFor(source)
+    };
+  }
+
+  /**
+   * Create a [BuildExportSourceClosureTask] based on the given [target] in
+   * the given [context].
+   */
+  static BuildExportSourceClosureTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new BuildExportSourceClosureTask(context, target);
+  }
+
+  /**
+   * Create a set representing the export closure of the given [library].
+   */
+  static void _buildExportClosure(
+      Set<LibraryElement> libraries, LibraryElement library) {
+    if (library != null && libraries.add(library)) {
+      for (ExportElement exportElement in library.exports) {
+        _buildExportClosure(libraries, exportElement.exportedLibrary);
+      }
+    }
+  }
+}
+
+/**
  * A task that builds a library element for a Dart library.
  */
 class BuildLibraryElementTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the defining [RESOLVED_UNIT1].
    */
   static const String DEFINING_RESOLVER_UNIT1_INPUT_NAME =
       'DEFINING_RESOLVER_UNIT1_INPUT_NAME';
 
   /**
@@ skipping 617 matching lines @@
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }