rework LocalLibraryContributor to resolve referenced units

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 121 matching lines @@
   /**
    * The [LibraryElement] representing dart:core
    */
   LibraryElement _coreLib;
 
   /**
    * The [DartType] for Object in dart:core
    */
   InterfaceType _objectType;
 
+  /**
+   * The resolved [CompilationUnitElement]s comprising the library
+   * or `null` if not computed.
+   */
+  List<CompilationUnitElement> _resolvedUnits;
+
   OpType _opType;
 
   final CompletionRequest _originalRequest;
 
   final CompletionPerformance performance;
 
   DartCompletionRequestImpl._(
       this.context,
       this.resourceProvider,
       this.searchEngine,
@@ skipping 108 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<CompilationUnitElement>> resolveUnits() async {
+    checkAborted();
+    if (_resolvedUnits != null) {
+      return _resolvedUnits;
+    }
+    LibraryElement libElem = libraryElement;
+    if (libElem == null) {
+      return null;
+    }
+    _resolvedUnits = <CompilationUnitElement>[];
+    for (CompilationUnitElement unresolvedUnit in libElem.units) {
+      CompilationUnit unit = await _computeAsync(
+          this,
+          new LibrarySpecificUnit(libElem.source, unresolvedUnit.source),
+          RESOLVED_UNIT3,
+          performance,
+          'resolve library unit');
+      checkAborted();
+      CompilationUnitElement resolvedUnit = unit?.element;
+      if (resolvedUnit != null) {
+        _resolvedUnits.add(resolvedUnit);
+      }
+    }
+    return _resolvedUnits;
+  }
+
   /**
    * Update the completion [target] and [dotTarget] based on the given [unit].
    */
   void _updateTargets(CompilationUnit unit) {
     _opType = null;
     dotTarget = null;
     target = new CompletionTarget.forOffset(unit, offset);
     AstNode node = target.containingNode;
     if (node is MethodInvocation) {
       if (identical(node.methodName, target.entity)) {
@@ skipping 78 matching lines @@
         await dartRequest.resolveExpression(node);
         performance.logElapseTime(FUNCTIONAL_ARG_TAG);
         dartRequest.checkAborted();
       }
     }
 
     performance.logElapseTime(BUILD_REQUEST_TAG);
     return dartRequest;
   }
 
-  static Future _computeAsync(CompletionRequest request, AnalysisTarget target,
-      ResultDescriptor descriptor, CompletionPerformance performance, String perfTag) async {
+  static Future _computeAsync(
+      CompletionRequest request,
+      AnalysisTarget target,
+      ResultDescriptor descriptor,
+      CompletionPerformance performance,
+      String perfTag) async {
     request.checkAborted();
     performance.logStartTime(perfTag);
     var result;
     try {
       result =
           await new AnalysisFutureHelper(request.context, target, descriptor)
               .computeAsync();
     } catch (e, s) {
       if (e is AnalysisNotScheduledError) {
         request.checkAborted();
@@ skipping 55 matching lines @@
               // Replacement range for import URI
               return new ReplacementRange(start, end - start);
             }
           }
         }
       }
     }
     return new ReplacementRange(requestOffset, 0);
   }
 }