support part file completions

pkg/analysis_server/lib/src/services/completion/dart_completion_manager.dart

 // Copyright (c) 2014, 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;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/arglist_computer.dart';
@@ skipping 61 matching lines @@
         context,
         searchEngine,
         source,
         new DartCompletionCache(context, source));
   }
 
   @override
   Future<bool> computeCache() {
     return waitForAnalysis().then((CompilationUnit unit) {
       if (unit != null && !cache.isImportInfoCached(unit)) {
-        return cache.computeImportInfo(unit, searchEngine);
+        return cache.computeImportInfo(unit, searchEngine, true);
       } else {
         return new Future.value(false);
       }
     });
   }
 
   /**
    * Compute suggestions based upon cached information only
    * then send an initial response to the client.
    * Return a list of computers for which [computeFull] should be called
@@ skipping 89 matching lines @@
       controller.close();
     }
   }
 
   /**
    * Return a future that either (a) completes with the resolved compilation
    * unit when analysis is complete, or (b) completes with null if the
    * compilation unit is never going to be resolved.
    */
   Future<CompilationUnit> waitForAnalysis() {
+    List<Source> libraries = context.getLibrariesContaining(source);
+    assert(libraries != null);

[Paul Berry, 2014/12/19 19:13:30]

Nit pick: the change you've made adds assertions, which is great.  But it drops
the defensive programming, because it means that when the code is run in
unchecked mode, the presence of null will cause an exception.

IMHO it's best to be defensive for the benefit of unchecked mode and use
assertions for the benefit of checked mode.  For example, instead of doing the
rewrite you've done in this patch set, you could go back to what you had in
patch set 1 and just add a single assert statement:

if (libraries == null || libraries.length == 0 || libraries[0] == null) {
  // Only libraries.length == 0 is expected to occur in practice;
  // the others are to avoid NRE's.
  assert(libraries != null && libraries.length == 0);
  return new Future.value(null);
}

Your call, though.

+    if (libraries.length == 0) {
+      return new Future.value(null);
+    }
+    Source libSource = libraries[0];
+    assert(libSource != null);
     return context.computeResolvedCompilationUnitAsync(
         source,
-        source).catchError((_) {
+        libSource).catchError((_) {
       // This source file is not scheduled for analysis, so a resolved
       // compilation unit is never going to get computed.
       return null;
     }, test: (e) => e is AnalysisNotScheduledError);
   }
 }
 
 /**
  * The context in which the completion is requested.
  */
@@ skipping 93 matching lines @@
   _ReplacementOffsetBuilder(this.request) {
     request.replacementOffset = request.offset;
     request.replacementLength = 0;
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
     request.replacementOffset = node.offset;
     request.replacementLength = node.length;
   }
 }