Add initial support for parts to the incremental kernel generator.

pkg/front_end/lib/src/incremental_resolved_ast_generator_impl.dart

 // Copyright (c) 2017, 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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart' as driver;
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart';
@@ skipping 49 matching lines @@
     var graph = await graphForProgram([_source], _options);
     var libraries = <Uri, ResolvedLibrary>{};
     if (!_schedulerStarted) {
       _scheduler.start();
       _schedulerStarted = true;
     }
     // The driver will request files from dart:, even though it actually uses
     // the data from the summary.  TODO(paulberry): fix this.
     _fileRepository.store(Uri.parse('dart:core'), '');
     for (var libraryCycle in graph.topologicallySortedCycles) {
-      for (var uri in libraryCycle.libraries.keys) {
-        var contents =
-            await _options.fileSystem.entityForUri(uri).readAsString();
-        _fileRepository.store(uri, contents);
+      for (var libraryUri in libraryCycle.libraries.keys) {
+        var libraryNode = libraryCycle.libraries[libraryUri];
+        var libraryContents =
+            await _options.fileSystem.entityForUri(libraryUri).readAsString();
+        _fileRepository.store(libraryUri, libraryContents);
+        for (var partUri in libraryNode.parts) {
+          var partContents =
+              await _options.fileSystem.entityForUri(partUri).readAsString();
+          _fileRepository.store(partUri, partContents);
+        }
       }
-      for (var uri in libraryCycle.libraries.keys) {
-        var result = await _driver.getResult(_fileRepository.pathForUri(uri));
+      for (var libraryUri in libraryCycle.libraries.keys) {
+        var libraryNode = libraryCycle.libraries[libraryUri];
+        var result = await _driver.getResult(_fileRepository.pathForUri(libraryUri));
         // TODO(paulberry): handle errors.
-        libraries[uri] = new ResolvedLibrary(result.unit);
+        var definingCompilationUnit = result.unit;
+        var partUnits = <Uri, CompilationUnit>{};
+        for (var partUri in libraryNode.parts) {
+          // Really we ought to have a driver API that lets us request a
+          // specific part of a given library.  Otherwise we will run into
+          // problems if a part is included in multiple libraries.
+          // TODO(paulberry): address this.
+          var partResult = await _driver.getResult(_fileRepository.pathForUri(partUri));
+          // TODO(paulberry): handle errors.
+          partUnits[partUri] = partResult.unit;
+        }
+        libraries[libraryUri] =
+            new ResolvedLibrary(definingCompilationUnit, partUnits);
       }
     }
     _driver.addFile(_fileRepository.pathForUri(_source));
     // TODO(paulberry): stop the scheduler
     return new DeltaLibraries(libraries);
   }
 
   Future<Null> init() async {
     // TODO(paulberry): can we just use null?
     var performanceLog = new driver.PerformanceLog(new _NullStringSink());
@@ skipping 144 matching lines @@
   Source forUri(String absoluteUri) {
     Uri uri = Uri.parse(absoluteUri);
     return new _SourceProxy(uri, _fileRepository.pathForUri(uri));
   }
 
   noSuchMethod(Invocation invocation) => unimplemented();
 
   Source resolveUri(Source containingSource, String containedUri) {
     // TODO(paulberry): re-use code from dependency_grapher_impl, and support
     // SDK URI resolution logic.
-    var absoluteUri = containingSource.uri.resolve(containedUri);
+    var absoluteUri = containingSource == null

[danrubel, 2017/01/19 20:06:39]

Is absoluteUri dynamic? IOW, will absoluteUri be a String if containingSource is
null, but a Uri if containingSource is not null? That feels a little awkward too
me. Perhaps change

    containingSource.uri.resolve(containedUri);
to
    containingSource.uri.resolve(containedUri).toString();

so that absoluteUri is always a string?

It would also be nicer to pass around instances of Uri rather than String, then
forUri(...) can accept a Uri rather than always having to call Uri.parse.  

That said there may be larger API issues compelling you to pass around Strings
rather than Uris, so entirely up to you how this should be handled.

[Paul Berry, 2017/01/19 20:29:46]

Whoops, thanks for catching this.  I took your suggestion of changing to
`containingSource.uri.resolve(containedUri).toString()`.

You guessed correctly that there are larger API issues compelling me to pass
around Strings.  Specifically the fact that this is a proxy object to interface
with existing analyzer code that deals with strings.  In the long run I hope to
get rid of these proxies entirely, and in the code I'm writing to replace them,
I'm trying to use URIs more consistently.

+        ? containedUri
+        : containingSource.uri.resolve(containedUri);
     return forUri(absoluteUri.toString());
   }
 
   @override
   Uri restoreUri(Source source) => source.uri;
 }
 
 class _SourceProxy extends BasicSource {
   @override
   final String fullName;
 
   _SourceProxy(Uri uri, this.fullName) : super(uri);
 
   int get modificationStamp => 0;
 
   noSuchMethod(Invocation invocation) => unimplemented();
 }