Add public and export namespaces to LibraryElement.

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: DART_ERRORS);
 
 /**
- * The export [Namespace] of a library.
- *
- * The result is only available for targets representing a Dart library.
- */
-final ResultDescriptor<Namespace> EXPORT_NAMESPACE =
-    new ResultDescriptor<Namespace>('EXPORT_NAMESPACE', null);
-
-/**
  * 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.
  *
@@ skipping 12 matching lines @@
  * [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 partial [LibraryElement] associated with a library.
  *
- * In addition to [LIBRARY_ELEMENT2] `entryPoint` is set, if the library does
- * not declare one already and one of the exported libraries exports one.
+ * In addition to [LIBRARY_ELEMENT2] `publicNamespace` is set.

[Brian Wilkerson, 2015/03/18 19:20:56]

"`publicNamespace`" --> "[LibraryElement.publicNamespace]" (and similarly below)

  *
  * The result is only available for targets representing a Dart library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT3 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT3', null);
 
 /**
+ * The partial [LibraryElement] associated with a library.
+ *
+ * In addition to [LIBRARY_ELEMENT3] `entryPoint` is set, if the library does
+ * not declare one already and one of the exported libraries exports one.
+ *
+ * Also `exportNamespace` is set.
+ *
+ * The result is only available for targets representing a Dart library.
+ */
+final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT4 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT4', 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 109 matching lines @@
 /**
  * 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.
+   * The input with a list of [LIBRARY_ELEMENT3]s of imported libraries.
    */
-  static const String IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME =
+  static const String IMPORTS_LIBRARY_ELEMENT_INPUT_NAME =
       'IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME';
 
   /**
-   * The input with a list of [LIBRARY_ELEMENT1]s of exported libraries.
+   * The input with a list of [LIBRARY_ELEMENT3]s of exported libraries.
    */
-  static const String EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME =
-      'EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME';
+  static const String EXPORTS_LIBRARY_ELEMENT_INPUT_NAME =
+      'EXPORTS_LIBRARY_ELEMENT_INPUT_NAME';
 
   /**
    * The input with a list of [SOURCE_KIND]s of imported libraries.
    */
   static const String IMPORTS_SOURCE_KIND_INPUT_NAME =
       'IMPORTS_SOURCE_KIND_INPUT_NAME';
 
   /**
    * The input with a list of [SOURCE_KIND]s of exported libraries.
    */
@@ skipping 18 matching lines @@
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     List<AnalysisError> errors = <AnalysisError>[];
     //
     // Prepare inputs.
     //
     CompilationUnit libraryUnit = getRequiredInput(RESOLVED_UNIT2_INPUT_NAME);
     Map<Source, LibraryElement> importLibraryMap =
-        getRequiredInput(IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME);
+        getRequiredInput(IMPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, LibraryElement> exportLibraryMap =
-        getRequiredInput(EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME);
+        getRequiredInput(EXPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, SourceKind> importSourceKindMap =
         getRequiredInput(IMPORTS_SOURCE_KIND_INPUT_NAME);
     Map<Source, SourceKind> exportSourceKindMap =
         getRequiredInput(EXPORTS_SOURCE_KIND_INPUT_NAME);
     //
     // Process inputs.
     //
     LibraryElementImpl libraryElement = libraryUnit.element.library;
     Source librarySource = libraryElement.source;
     //
@@ skipping 106 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 library [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
       RESOLVED_UNIT2_INPUT_NAME: RESOLVED_UNIT2.inputFor(source),
-      IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
+      IMPORTS_LIBRARY_ELEMENT_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
               IMPORTED_LIBRARIES.inputFor(source),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
-      EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
+      EXPORTS_LIBRARY_ELEMENT_INPUT_NAME:
           new ListToMapTaskInput<Source, LibraryElement>(
               EXPORTED_LIBRARIES.inputFor(source),
               (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
       IMPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
               IMPORTED_LIBRARIES.inputFor(source),
               (Source source) => SOURCE_KIND.inputFor(source)),
       EXPORTS_SOURCE_KIND_INPUT_NAME:
           new ListToMapTaskInput<Source, SourceKind>(
               EXPORTED_LIBRARIES.inputFor(source),
@@ skipping 102 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_NAMESPACE] and [LIBRARY_ELEMENT3] for a library.
+ * A task that builds [EXPORT_NAMESPACE] and [LIBRARY_ELEMENT4] for a library.
  */
 class BuildExportNamespaceTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the input for [LIBRARY_ELEMENT2] of a library.
+   * The name of the input for [LIBRARY_ELEMENT3] of a library.
    */
-  static const String LIBRARY2_ELEMENT_INPUT = 'LIBRARY2_ELEMENT_INPUT';
-
-  /**
-   * The a [Source] to [PUBLIC_NAMESPACE] map input.
-   */
-  static const String PUBLIC_NAMESPACES_INPUT = 'PUBLIC_NAMESPACES_INPUT';
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BuildExportNamespaceTask', createTask, buildInputs, <ResultDescriptor>[
-    EXPORT_NAMESPACE,
-    LIBRARY_ELEMENT3
-  ]);
+      'BuildExportNamespaceTask', createTask, buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT4]);
 
   BuildExportNamespaceTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
-    LibraryElementImpl library = getRequiredInput(LIBRARY2_ELEMENT_INPUT);
-    Map<Source, Namespace> publicNamespaces =
-        getRequiredInput(PUBLIC_NAMESPACES_INPUT);
+    LibraryElementImpl library = getRequiredInput(LIBRARY_INPUT);
     //
     // Compute export namespace.
     //
-    ExportNamespaceBuilder builder =
-        new ExportNamespaceBuilder(publicNamespaces);
+    ExportNamespaceBuilder builder = new ExportNamespaceBuilder();
     Namespace namespace = builder.build(library);
+    library.exportNamespace = namespace;
     //
     // Update entry point.
     //
     if (library.entryPoint == null) {
       Iterable<Element> exportedElements = namespace.definedNames.values;
       library.entryPoint = exportedElements.firstWhere(
           (element) => element is FunctionElement && element.isEntryPoint,
           orElse: () => null);
     }
     //
     // Record outputs.
     //
-    outputs[EXPORT_NAMESPACE] = namespace;
-    outputs[LIBRARY_ELEMENT3] = library;
+    outputs[LIBRARY_ELEMENT4] = library;
   }
 
   /**
    * 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),
-      PUBLIC_NAMESPACES_INPUT: new ListToMapTaskInput<Source, Namespace>(
-          EXPORT_SOURCE_CLOSURE.inputFor(source),
-          (Source source) => PUBLIC_NAMESPACE.inputFor(source))
+      LIBRARY_INPUT: LIBRARY_ELEMENT3.inputFor(source),
+      'exportsLibraryPublicNamespace':
+          new ListToMapTaskInput<Source, LibraryElement>(
+              EXPORT_SOURCE_CLOSURE.inputFor(source),
+              (Source source) => LIBRARY_ELEMENT3.inputFor(source))
     };
   }
 
   /**
    * Create a [BuildExportNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportNamespaceTask(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.
+   * The name of the input for [LIBRARY_ELEMENT3] 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]);
 
@@ skipping 321 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new BuildLibraryElementTask(context, target);
   }
 }
 
 /**
  * A task that builds [PUBLIC_NAMESPACE] for a library.
  */
 class BuildPublicNamespaceTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the input for [LIBRARY_ELEMENT1] of a library.
+   * The name of the input for [LIBRARY_ELEMENT2] of a library.
    */
-  static const String BUILT_LIBRARY_ELEMENT_INPUT_NAME =
-      'BUILT_LIBRARY_ELEMENT_INPUT_NAME';
+  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BUILD_PUBLIC_NAMESPACE', createTask, buildInputs,
-      <ResultDescriptor>[PUBLIC_NAMESPACE]);
+      'BuildPublicNamespaceTask', createTask, buildInputs,
+      <ResultDescriptor>[LIBRARY_ELEMENT3]);
 
   BuildPublicNamespaceTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
-    LibraryElement library = getRequiredInput(BUILT_LIBRARY_ELEMENT_INPUT_NAME);
-    Namespace namespace = new PublicNamespaceBuilder().build(library);
-    outputs[PUBLIC_NAMESPACE] = namespace;
+    LibraryElementImpl library = getRequiredInput(LIBRARY_INPUT);
+    library.publicNamespace = new PublicNamespaceBuilder().build(library);
+    outputs[LIBRARY_ELEMENT3] = library;
   }
 
   /**
    * 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>{
-      BUILT_LIBRARY_ELEMENT_INPUT_NAME: LIBRARY_ELEMENT1.inputFor(source)
+      LIBRARY_INPUT: LIBRARY_ELEMENT2.inputFor(source)
     };
   }
 
   /**
    * Create a [BuildPublicNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildPublicNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildPublicNamespaceTask(context, target);
@@ skipping 23 matching lines @@
 
   BuildTypeProviderTask(
       InternalAnalysisContext context, AnalysisContextTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
-    Namespace coreNamespace = getRequiredInput(CORE_INPUT);
-    Namespace asyncNamespace = getRequiredInput(ASYNC_INPUT);
+    LibraryElement coreLibrary = getRequiredInput(CORE_INPUT);
+    LibraryElement asyncLibrary = getRequiredInput(ASYNC_INPUT);
+    Namespace coreNamespace = coreLibrary.publicNamespace;
+    Namespace asyncNamespace = asyncLibrary.publicNamespace;
     //
     // Record outputs.
     //
     TypeProvider typeProvider =
         new TypeProviderImpl.forNamespaces(coreNamespace, asyncNamespace);
     (context as ExtendedAnalysisContext).typeProvider = typeProvider;
     outputs[TYPE_PROVIDER] = typeProvider;
   }
 
   static Map<String, TaskInput> buildInputs(AnalysisContextTarget target) {
     SourceFactory sourceFactory = target.context.sourceFactory;
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
     return <String, TaskInput>{
-      CORE_INPUT: PUBLIC_NAMESPACE.inputFor(coreSource),
-      ASYNC_INPUT: PUBLIC_NAMESPACE.inputFor(asyncSource)
+      CORE_INPUT: LIBRARY_ELEMENT3.inputFor(coreSource),
+      ASYNC_INPUT: LIBRARY_ELEMENT3.inputFor(asyncSource)
     };
   }
 
   /**
    * Create a [BuildTypeProviderTask] based on the given [context].
    */
   static BuildTypeProviderTask createTask(
       AnalysisContext context, AnalysisContextTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
 }
 
 /**
  * The helper for building the export [Namespace] of a [LibraryElement].
  */
 class ExportNamespaceBuilder {
-  final Map<Source, Namespace> _publicNamespaces;
-
-  ExportNamespaceBuilder(this._publicNamespaces);
-
   /**
    * Build the export [Namespace] of the given [LibraryElement].
    */
   Namespace build(LibraryElement library) {
     return new Namespace(
         _createExportMapping(library, new HashSet<LibraryElement>()));
   }
 
   /**
    * Create a mapping table representing the export namespace of the given
@@ skipping 18 matching lines @@
           // valid library.
           //
           HashMap<String, Element> exportedNames =
               _createExportMapping(exportedLibrary, visitedElements);
           exportedNames = _applyCombinators(exportedNames, element.combinators);
           definedNames.addAll(exportedNames);
         }
       }
       // Add names of the public namespace.
       {
-        Namespace publicNamespace = _publicNamespaces[library.source];
+        Namespace publicNamespace = library.publicNamespace;
         if (publicNamespace != null) {
           definedNames.addAll(publicNamespace.definedNames);
         }
       }
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
 
@@ skipping 330 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);
   }
 }