Task: Create Export Namespace.

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 10 matching lines @@
  *
  * 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 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.
+ *
+ * The result is only available for targets representing a Dart library.
+ */
+final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT3 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT3', 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 270 matching lines @@
       ImportElementImpl importElement = new ImportElementImpl(-1);
       importElement.importedLibrary = importLibraryMap[coreLibrarySource];
       importElement.synthetic = true;
       imports.add(importElement);
     }
     //
     // Populate the library element.
     //
     libraryElement.imports = imports;
     libraryElement.exports = exports;
-    // TODO(scheglov) move after EXPORT_NAMESPACE or just this task
-//    if (libraryElement.entryPoint == null) {
-//      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
@@ skipping 123 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.
+ */
+class BuildExportNamespaceTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the input for [LIBRARY_ELEMENT2] 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';
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'BuildExportNamespaceTask', createTask, buildInputs, <ResultDescriptor>[
+    EXPORT_NAMESPACE,
+    LIBRARY_ELEMENT3
+  ]);
+
+  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);
+    //
+    // Compute export namespace.
+    //
+    ExportNamespaceBuilder builder =
+        new ExportNamespaceBuilder(publicNamespaces);
+    Namespace namespace = builder.build(library);
+    //
+    // 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;
+  }
+
+  /**
+   * 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))
+    };
+  }
+
+  /**
+   * 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.
    */
   static const String LIBRARY2_ELEMENT_INPUT = 'LIBRARY2_ELEMENT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 434 matching lines @@
   /**
    * 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
+   * [library].
+   *
+   * The given [visitedElements] a set of libraries that do not need to be
+   * visited when processing the export directives of the given library because
+   * all of the names defined by them will be added by another library.
+   */
+  HashMap<String, Element> _createExportMapping(
+      LibraryElement library, HashSet<LibraryElement> visitedElements) {
+    visitedElements.add(library);
+    try {
+      HashMap<String, Element> definedNames = new HashMap<String, Element>();
+      // Add names of the export directives.
+      for (ExportElement element in library.exports) {
+        LibraryElement exportedLibrary = element.exportedLibrary;
+        if (exportedLibrary != null &&
+            !visitedElements.contains(exportedLibrary)) {
+          //
+          // The exported library will be null if the URI does not reference a
+          // 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];
+        if (publicNamespace != null) {
+          definedNames.addAll(publicNamespace.definedNames);
+        }
+      }
+      return definedNames;
+    } finally {
+      visitedElements.remove(library);
+    }
+  }
+
+  /**
+   * Apply the given [combinators] to all of the names in [definedNames].
+   */
+  static HashMap<String, Element> _applyCombinators(
+      HashMap<String, Element> definedNames,
+      List<NamespaceCombinator> combinators) {
+    for (NamespaceCombinator combinator in combinators) {
+      if (combinator is HideElementCombinator) {
+        _hide(definedNames, combinator.hiddenNames);
+      } else if (combinator is ShowElementCombinator) {
+        definedNames = _show(definedNames, combinator.shownNames);
+      }
+    }
+    return definedNames;
+  }
+
+  /**
+   * Hide all of the [hiddenNames] by removing them from the given
+   * [definedNames].
+   */
+  static void _hide(
+      HashMap<String, Element> definedNames, List<String> hiddenNames) {
+    for (String name in hiddenNames) {
+      definedNames.remove(name);
+      definedNames.remove('$name=');
+    }
+  }
+
+  /**
+   * Show only the given [shownNames] by removing all other names from the given
+   * [definedNames].
+   */
+  static HashMap<String, Element> _show(
+      HashMap<String, Element> definedNames, List<String> shownNames) {
+    HashMap<String, Element> newNames = new HashMap<String, Element>();
+    for (String name in shownNames) {
+      Element element = definedNames[name];
+      if (element != null) {
+        newNames[name] = element;
+      }
+      String setterName = '$name=';
+      element = definedNames[setterName];
+      if (element != null) {
+        newNames[setterName] = element;
+      }
+    }
+    return newNames;
+  }
+}
+
+/**
  * A pair of a library [Source] and a unit [Source] in this library.
  */
 class LibraryUnitTarget implements AnalysisTarget {
   final Source library;
   final Source unit;
   LibraryUnitTarget(this.library, this.unit);
 
   @override
   int get hashCode {
     return JenkinsSmiHash.combine(library.hashCode, unit.hashCode);
@@ skipping 78 matching lines @@
             if (directive is ExportDirective) {
               exportedSources.add(referencedSource);
             } else if (directive is ImportDirective) {
               importedSources.add(referencedSource);
             } else if (directive is PartDirective) {
               if (referencedSource != source) {
                 includedSources.add(referencedSource);
               }
             } else {
               throw new AnalysisException(
-                  "$runtimeType failed to handle a ${directive.runtimeType}");
+                  '$runtimeType failed to handle a ${directive.runtimeType}');
             }
           }
         }
       }
     }
     //
     // Always include "dart:core" source.
     //
     Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
     importedSources.add(coreLibrarySource);
@@ skipping 170 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);
   }
 }