Simplify the API for incremental_resolved_ast_generator.

pkg/front_end/lib/incremental_resolved_ast_generator.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:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/incremental_resolved_ast_generator_impl.dart';
-import 'package:analyzer/dart/ast/ast.dart';
 
 import 'compiler_options.dart';
 
 /// Represents the difference between "old" and "new" states of a program.
 ///
 /// Not intended to be implemented or extended by clients.
 class DeltaLibraries {
-  /// The new state of the program, as a map from Uri to [ResolvedLibrary].
+  /// The new state of the program, as a two-layer map.
+  ///
+  /// The outer map key is the library URI.  The inner map key is the
+  /// compilation unit (part) URI.  The map values are the resolved compilation
+  /// units.
   ///
   /// Libraries whose resolved AST is known to be unchanged since the last
   /// [DeltaLibraries] are not included.
-  final Map<Uri, ResolvedLibrary> newState;
+  final Map<Uri, Map<Uri, CompilationUnit>> newState;
 
   DeltaLibraries(this.newState);
 
-/// TODO(paulberry): add information about libraries that were removed.
-}
-
-/// Represents the resolved ASTs for all the compilation units in a single
-/// library.
-///
-/// Not intended to be implemented or extended by clients.
-class ResolvedLibrary {
-  final CompilationUnit definingCompilationUnit;
-
-  final Map<Uri, CompilationUnit> partUnits;
-
-  ResolvedLibrary(this.definingCompilationUnit, this.partUnits);
+  /// TODO(paulberry): add information about libraries that were removed.
 }
 
 /// Interface for generating an initial resolved representation of a program and
 /// keeping it up to date as incremental changes are made.
 ///
 /// This class maintains an internal "previous program state"; each
 /// time [computeDelta] is called, it updates the previous program state and
 /// produces a representation of what has changed.  When there are few changes,
 /// a call to [computeDelta] should be much faster than compiling the whole
 /// program from scratch.
@@ skipping 12 matching lines @@
 /// Not intended to be implemented or extended by clients.
 abstract class IncrementalResolvedAstGenerator {
   /// Creates an [IncrementalResolvedAstGenerator] which is prepared to generate
   /// resolved ASTs for the program whose main library is in the given
   /// [source].
   ///
   /// No file system access is performed by this constructor; the initial
   /// "previous program state" is an empty program containing no code, and the
   /// initial set of valid sources is empty.  To obtain a resolved AST
   /// representation of the program, call [computeDelta].
-  factory IncrementalResolvedAstGenerator(Uri source, CompilerOptions options) =>
-      new IncrementalResolvedAstGeneratorImpl(source, new ProcessedOptions(options));
+  factory IncrementalResolvedAstGenerator(
+          Uri source, CompilerOptions options) =>
+      new IncrementalResolvedAstGeneratorImpl(
+          source, new ProcessedOptions(options));
 
   /// Generates a resolved AST representation of the changes to the program,
   /// assuming that all valid sources are unchanged since the last call to
   /// [computeDelta].
   ///
   /// Source files in the set of valid sources are guaranteed not to be re-read
   /// from disk; they are assumed to be unchanged regardless of the state of the
   /// filesystem.
   ///
   /// If the future completes successfully, the previous file state is updated
@@ skipping 13 matching lines @@
 
   /// Remove all source files from the set of valid sources.  This guarantees
   /// that all files will be re-read on the next call to [computeDelta].
   ///
   /// Note that this does not erase the previous program state; the next time
   /// [computeDelta] is called, if parts of the program are discovered to be
   /// unchanged, parts of the previous program state will still be re-used to
   /// speed up compilation.
   void invalidateAll();
 }