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 171 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);
+    if (libraries == null || libraries.length == 0 || libraries[0] == null) {

[Paul Berry, 2014/12/18 18:37:02]

Are all of these possibilities expected to arise in practice?  My understanding
of the contract of getLibrariesContainingSource() is that it always returns a
non-null list containing non-null elements, so the only case which can actually
arise is libraries.length == 0.  I'm fine with defensive programming, but we
should include an assert statement inside the body of the if statement so that
(a) if getLibrariesContainingSource() ever breaks its contract we'll find out,
and (b) future readers of the code won't draw incorrect conclusions about the
contract.

Accordingly, I'd recommend adding this assertion:

assert(libraries != null && libraries.length == 0);

[danrubel, 2014/12/19 18:46:09]

The dartdoc does not clearly state that it will not return a null array or null
element in the array. That said, I like your point that those should not happen
in practice and thus should be coded as assert statements. Done.

+      return new Future.value(null);
+    }
     return context.computeResolvedCompilationUnitAsync(
         source,
-        source).catchError((_) {
+        libraries[0]).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;
   }
 }