Compute explicit imports

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 'dart:math' as math;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1892 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new GenerateHintsTask(context, target);
   }
 }
 
 /**
  * The memento for [ParseDartTask].
  */
 class ParseDartMemento {
   final Token inputTokenStream;
+  final List<Source> explicitlyImportedLibraries;
   final List<Source> exportedLibraries;
   final List<Source> importedLibraries;
   final List<Source> includedParts;
   final List<AnalysisError> parseErrors;
   final CompilationUnit parsedUnit;
   final SourceKind sourceKind;
   final List<Source> units;
-  ParseDartMemento(this.inputTokenStream, this.exportedLibraries,
+  ParseDartMemento(this.inputTokenStream, this.explicitlyImportedLibraries, this.exportedLibraries,
       this.importedLibraries, this.includedParts, this.parseErrors,
       this.parsedUnit, this.sourceKind, this.units);
 }
 
 /**
  * A task that parses the content of a Dart file, producing an AST structure.
  */
 class ParseDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information produced for the
    * file.
    */
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
    * The name of the input whose value is the token stream produced for the file.
    */
   static const String TOKEN_STREAM_INPUT_NAME = 'TOKEN_STREAM_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('ParseDartTask',
       createTask, buildInputs, <ResultDescriptor>[
+    EXPLICITLY_IMPORTED_LIBRARIES,
     EXPORTED_LIBRARIES,
     IMPORTED_LIBRARIES,
     INCLUDED_PARTS,
     PARSE_ERRORS,
     PARSED_UNIT,
     SOURCE_KIND,
     UNITS
   ]);
 
   /**
    * Initialize a newly created task to parse the content of the Dart file
    * associated with the given [target] in the given [context].
    */
   ParseDartTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     Source source = getRequiredSource();
     LineInfo lineInfo = getRequiredInput(LINE_INFO_INPUT_NAME);
     Token tokenStream = getRequiredInput(TOKEN_STREAM_INPUT_NAME);
 
     if (inputMemento is ParseDartMemento) {
       ParseDartMemento memento = inputMemento;
       if (identical(memento.inputTokenStream, tokenStream)) {
         outputMemento = memento;
+        outputs[EXPLICITLY_IMPORTED_LIBRARIES] = memento.explicitlyImportedLibraries;
         outputs[EXPORTED_LIBRARIES] = memento.exportedLibraries;
         outputs[IMPORTED_LIBRARIES] = memento.importedLibraries;
         outputs[INCLUDED_PARTS] = memento.includedParts;
         outputs[PARSE_ERRORS] = memento.parseErrors;
         outputs[PARSED_UNIT] = memento.parsedUnit;
         outputs[SOURCE_KIND] = memento.sourceKind;
         outputs[UNITS] = memento.units;
         return;
       }
     }
 
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Parser parser = new Parser(source, errorListener);
     AnalysisOptions options = context.analysisOptions;
     parser.parseFunctionBodies = options.analyzeFunctionBodiesPredicate(source);
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
     bool hasNonPartOfDirective = false;
     bool hasPartOfDirective = false;
+    HashSet<Source> explicitlyImportedSourceSet = new HashSet<Source>();
     HashSet<Source> exportedSourceSet = new HashSet<Source>();
-    HashSet<Source> importedSourceSet = new HashSet<Source>();
     HashSet<Source> includedSourceSet = new HashSet<Source>();
     for (Directive directive in unit.directives) {
       if (directive is PartOfDirective) {
         hasPartOfDirective = true;
       } else {
         hasNonPartOfDirective = true;
         if (directive is UriBasedDirective) {
           Source referencedSource =
               resolveDirective(context, source, directive, errorListener);
           if (referencedSource != null) {
             if (directive is ExportDirective) {
               exportedSourceSet.add(referencedSource);
             } else if (directive is ImportDirective) {
-              importedSourceSet.add(referencedSource);
+              explicitlyImportedSourceSet.add(referencedSource);
             } else if (directive is PartDirective) {
               if (referencedSource != source) {
                 includedSourceSet.add(referencedSource);
               }
             } else {
               throw new AnalysisException(
                   '$runtimeType failed to handle a ${directive.runtimeType}');
             }
           }
         }
       }
     }
     //
     // Always include "dart:core" source.
     //
+    HashSet<Source> importedSourceSet = new HashSet.from(explicitlyImportedSourceSet);
     Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
     importedSourceSet.add(coreLibrarySource);
     //
     // Compute kind.
     //
     SourceKind sourceKind = SourceKind.LIBRARY;
     if (!hasNonPartOfDirective && hasPartOfDirective) {
       sourceKind = SourceKind.PART;
     }
     //
     // Record outputs.
     //
+    List<Source> explicitlyImportedSources = explicitlyImportedSourceSet.toList();
     List<Source> exportedSources = exportedSourceSet.toList();
     List<Source> importedSources = importedSourceSet.toList();
     List<Source> includedSources = includedSourceSet.toList();
     List<AnalysisError> parseErrors = errorListener.errors;
     List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
+    outputs[EXPLICITLY_IMPORTED_LIBRARIES] = explicitlyImportedSources;
     outputs[EXPORTED_LIBRARIES] = exportedSources;
     outputs[IMPORTED_LIBRARIES] = importedSources;
     outputs[INCLUDED_PARTS] = includedSources;
     outputs[PARSE_ERRORS] = parseErrors;
     outputs[PARSED_UNIT] = unit;
     outputs[SOURCE_KIND] = sourceKind;
     outputs[UNITS] = unitSources;
-    outputMemento = new ParseDartMemento(tokenStream, exportedSources,
+    outputMemento = new ParseDartMemento(tokenStream, explicitlyImportedSources, exportedSources,
         importedSources, includedSources, parseErrors, unit, sourceKind,
         unitSources);
   }
 
   /**
    * 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
    * [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
@@ skipping 614 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }