rework completion request resolve imports

pkg/analysis_server/lib/src/services/completion/dart/completion_manager.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 services.completion.dart.manager;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/provisional/completion/completion_core.dart'
@@ skipping 122 matching lines @@
    * The [LibraryElement] representing dart:core
    */
   LibraryElement _coreLib;
 
   /**
    * The [DartType] for Object in dart:core
    */
   InterfaceType _objectType;
 
   /**
+   * A list of resolved [ImportElement]s for the imported libraries
+   * or `null` if not computed.
+   */
+  List<ImportElement> _resolvedImports;
+
+  /**
    * The resolved [CompilationUnitElement]s comprising the library
    * or `null` if not computed.
    */
   List<CompilationUnitElement> _resolvedUnits;
 
   OpType _opType;
 
   final CompletionRequest _originalRequest;
 
   final CompletionPerformance performance;
@@ skipping 58 matching lines @@
     return _opType;
   }
 
   /**
    * Throw [AbortCompletion] if the completion request has been aborted.
    */
   void checkAborted() {
     _originalRequest.checkAborted();
   }
 
-  // For internal use only
-  @override
-  Future<List<Directive>> resolveDirectives() async {
-    checkAborted();
-
-    CompilationUnit libUnit;
-    if (librarySource != null) {
-      // TODO(danrubel) only resolve the directives
-      libUnit = await _computeAsync(
-          this,
-          new LibrarySpecificUnit(librarySource, librarySource),
-          RESOLVED_UNIT3,
-          performance,
-          'resolve directives');
-    }
-    return libUnit?.directives;
-  }
-
   @override
   Future resolveExpression(Expression expression) async {
     checkAborted();
 
     // Return immediately if the expression has already been resolved
     if (expression.propagatedType != null) {
       return;
     }
 
     // Gracefully degrade if librarySource cannot be determined
@@ skipping 18 matching lines @@
     // Gracefully degrade if unit cannot be resolved
     if (resolvedUnit == null) {
       return;
     }
 
     // Recompute the target for the newly resolved unit
     _updateTargets(resolvedUnit);
   }
 
   @override
+  Future<List<ImportElement>> resolveImports() async {
+    checkAborted();
+    if (_resolvedImports != null) {
+      return _resolvedImports;
+    }
+    LibraryElement libElem = libraryElement;
+    if (libElem == null) {
+      return null;
+    }
+    _resolvedImports = <ImportElement>[];
+    for (ImportElement importElem in libElem.imports) {
+      if (importElem.importedLibrary.exportNamespace == null) {
+        await _computeAsync(this, importElem.importedLibrary.source,
+            LIBRARY_ELEMENT4, performance, 'resolve imported library');
+        checkAborted();
+      }
+      _resolvedImports.add(importElem);
+    }
+    return _resolvedImports;
+  }
+
+  @override
   Future<List<CompilationUnitElement>> resolveUnits() async {
     checkAborted();
     if (_resolvedUnits != null) {
       return _resolvedUnits;
     }
     LibraryElement libElem = libraryElement;
     if (libElem == null) {
       return null;
     }
     _resolvedUnits = <CompilationUnitElement>[];
@@ skipping 40 matching lines @@
         dotTarget = node.prefix;
       }
     }
   }
 
   /**
    * Return a [Future] that completes with a newly created completion request
    * based on the given [request]. This method will throw [AbortCompletion]
    * if the completion request has been aborted.
    */
-  static Future<DartCompletionRequest> from(CompletionRequest request) async {
+  static Future<DartCompletionRequest> from(CompletionRequest request,
+      {ResultDescriptor resultDescriptor}) async {
     request.checkAborted();
     CompletionPerformance performance =
         (request as CompletionRequestImpl).performance;
     const BUILD_REQUEST_TAG = 'build DartCompletionRequest';
     performance.logStartTime(BUILD_REQUEST_TAG);
 
     Source source = request.source;
     AnalysisContext context = request.context;
 
     const PARSE_TAG = 'parse unit';
     performance.logStartTime(PARSE_TAG);
     CompilationUnit unit = request.context.computeResult(source, PARSED_UNIT);
     performance.logElapseTime(PARSE_TAG);
 
     Source libSource;
     if (unit.directives.any((d) => d is PartOfDirective)) {
       List<Source> libraries = context.getLibrariesContaining(source);
       if (libraries.isNotEmpty) {
         libSource = libraries[0];
       }
     } else {
       libSource = source;
     }
 
     // Most (all?) contributors need declarations in scope to be resolved
     if (libSource != null) {
       unit = await _computeAsync(
           request,
           new LibrarySpecificUnit(libSource, source),
-          RESOLVED_UNIT3,
+          resultDescriptor ?? RESOLVED_UNIT3,
           performance,
           'resolve declarations');
     }
 
     DartCompletionRequestImpl dartRequest = new DartCompletionRequestImpl._(
         request.context,
         request.resourceProvider,
         request.searchEngine,
         libSource,
         request.source,
@@ skipping 94 matching lines @@
               // Replacement range for import URI
               return new ReplacementRange(start, end - start);
             }
           }
         }
       }
     }
     return new ReplacementRange(requestOffset, 0);
   }
 }