Several tests for AnalysisDriver and an elements.dart tweak.

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 224 matching lines @@
           _verifyApiSignatureOfChangedFile(path);
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // Analyze a requested file.
         if (_requestedFiles.isNotEmpty) {
           String path = _requestedFiles.keys.first;
           AnalysisResult result = _computeAnalysisResult(path, withUnit: true);
+          // Notify the completers.
           _requestedFiles.remove(path).forEach((completer) {
             completer.complete(result);
           });
+          // Remove from to be analyzed and produce it now.
+          _filesToAnalyze.remove(path);
           yield result;
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // Analyze a priority file.
         if (_priorityFiles.isNotEmpty) {
           bool analyzed = false;
           for (String path in _priorityFiles) {
@@ skipping 165 matching lines @@
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $source', () {
       // Still no result, compute and store it.
       _File file = new _File.forResolution(this, source);
       _LibraryContext libraryContext = _createLibraryContext(file);
       AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
       try {
         analysisContext.setContents(file.source, file.content);
         // TODO(scheglov) Add support for parts.
-        CompilationUnit resolvedUnit =
-            analysisContext.resolveCompilationUnit2(file.source, file.source);
+        CompilationUnit resolvedUnit = withUnit
+            ? analysisContext.resolveCompilationUnit2(file.source, file.source)
+            : null;
         List<AnalysisError> errors = analysisContext.computeErrors(file.source);
 
         // Store the result into the cache.
         {
           List<int> bytes = new AnalysisDriverResolvedUnitBuilder(
                   errors: errors
                       .map((error) => new AnalysisDriverUnitErrorBuilder(
                           offset: error.offset,
                           length: error.length,
                           uniqueName: error.errorCode.uniqueName,
                           message: error.message,
                           correction: error.correction))
                       .toList())
               .toBuffer();
           String key = _getResolvedUnitKey(file);
           _byteStore.put(key, bytes);
         }
 
-        // Return the full result.
+        // Return the result, full or partial.
         _logger.writeln('Computed new analysis result.');
-        return new AnalysisResult(file.path, file.uri, file.content,
-            file.contentHash, resolvedUnit, errors);
+        return new AnalysisResult(
+            file.path,
+            file.uri,
+            withUnit ? file.content : null,
+            file.contentHash,
+            resolvedUnit,
+            errors);
       } finally {
         analysisContext.dispose();
       }
     });
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
 
@@ skipping 677 matching lines @@
     await _completer.future;
     _completer = new Completer<Null>();
   }
 
   /**
    * Complete the [signal] future if it is not completed yet. It is safe to
    * call this method multiple times, but the [signal] will complete only once.
    */
   void notify() {
     if (!_completer.isCompleted) {
-      _completer.complete(true);
+      _completer.complete(null);
     }
   }
 }
 
 /**
  * TODO(scheglov) document
  */
 class _ReferencedUris {
   bool isLibrary = true;
   final List<String> imported = <String>[];
   final List<String> exported = <String>[];
   final List<String> parted = <String>[];
 
   factory _ReferencedUris(UnlinkedUnit unit) {
     _ReferencedUris referenced = new _ReferencedUris._();
     referenced.parted.addAll(unit.publicNamespace.parts);
     for (UnlinkedImport import in unit.imports) {
       if (!import.isImplicit) {
         referenced.imported.add(import.uri);
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }