Simplify the API for incremental_resolved_ast_generator.

pkg/front_end/test/incremental_resolved_ast_generator_test.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/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
@@ skipping 26 matching lines @@
 @reflectiveTest
 class IncrementalResolvedAstGeneratorTest {
   static final sdkSummaryUri = Uri.parse('special:sdk_summary');
 
   /// Virtual filesystem for testing.
   final fileSystem = new MemoryFileSystem(pathos.posix, Uri.parse('file:///'));
 
   /// The object under test.
   IncrementalResolvedAstGenerator incrementalResolvedAstGenerator;
 
-  Future<Map<Uri, ResolvedLibrary>> getInitialProgram(Uri startingUri) async {
+  Future<Map<Uri, Map<Uri, CompilationUnit>>> getInitialProgram(
+      Uri startingUri) async {
     fileSystem.entityForUri(sdkSummaryUri).writeAsBytesSync(_sdkSummary);
     incrementalResolvedAstGenerator = new IncrementalResolvedAstGenerator(
         startingUri,
         new CompilerOptions()
           ..fileSystem = fileSystem
           ..chaseDependencies = true
           ..sdkSummary = sdkSummaryUri
           ..packagesFileUri = new Uri());
     return (await incrementalResolvedAstGenerator.computeDelta()).newState;
   }
 
   test_incrementalUpdate_referenceToCore() async {
     writeFiles({'/foo.dart': 'main() { print(1); }'});
     var fooUri = Uri.parse('file:///foo.dart');
     var initialProgram = await getInitialProgram(fooUri);
     expect(initialProgram.keys, unorderedEquals([fooUri]));
 
     void _checkMain(CompilationUnit unit, int expectedArgument) {
       var mainStatements = _getFunctionStatements(_getFunction(unit, 'main'));
       expect(mainStatements, hasLength(1));
       _checkPrintLiteralInt(mainStatements[0], expectedArgument);
     }
 
-    _checkMain(initialProgram[fooUri].definingCompilationUnit, 1);
+    _checkMain(initialProgram[fooUri][fooUri], 1);
     writeFiles({'/foo.dart': 'main() { print(2); }'});
     // Verify that the file isn't actually reread until invalidate is called.
     var deltaProgram1 = await incrementalResolvedAstGenerator.computeDelta();
     // TODO(paulberry): since there is no delta, computeDelta should return an
     // empty map.
     // expect(deltaProgram1.newState, isEmpty);
     expect(deltaProgram1.newState.keys, unorderedEquals([fooUri]));
-    _checkMain(deltaProgram1.newState[fooUri].definingCompilationUnit, 1);
+    _checkMain(deltaProgram1.newState[fooUri][fooUri], 1);
     incrementalResolvedAstGenerator.invalidateAll();
     var deltaProgram2 = await incrementalResolvedAstGenerator.computeDelta();
     expect(deltaProgram2.newState.keys, unorderedEquals([fooUri]));
-    _checkMain(deltaProgram2.newState[fooUri].definingCompilationUnit, 2);
+    _checkMain(deltaProgram2.newState[fooUri][fooUri], 2);
   }
 
   test_invalidateAllBeforeInitialProgram() async {
     incrementalResolvedAstGenerator = new IncrementalResolvedAstGenerator(
         Uri.parse('file:///foo.dart'),
         new CompilerOptions()
           ..fileSystem = fileSystem
           ..chaseDependencies = true
           ..packagesFileUri = new Uri());
     incrementalResolvedAstGenerator.invalidateAll();
   }
 
   test_part() async {
     writeFiles({
       '/foo.dart': 'library foo; part "bar.dart"; main() { print(1); f(); }',
       '/bar.dart': 'part of foo; f() { print(2); }'
     });
     var fooUri = Uri.parse('file:///foo.dart');
     var barUri = Uri.parse('file:///bar.dart');
     var initialProgram = await getInitialProgram(fooUri);
     expect(initialProgram.keys, unorderedEquals([fooUri]));
-    expect(initialProgram[fooUri].partUnits.keys, unorderedEquals([barUri]));
+    expect(initialProgram[fooUri].keys, unorderedEquals([fooUri, barUri]));
     var mainStatements = _getFunctionStatements(
-        _getFunction(initialProgram[fooUri].definingCompilationUnit, 'main'));
-    var fDeclaration =
-        _getFunction(initialProgram[fooUri].partUnits[barUri], 'f');
+        _getFunction(initialProgram[fooUri][fooUri], 'main'));
+    var fDeclaration = _getFunction(initialProgram[fooUri][barUri], 'f');
     var fStatements = _getFunctionStatements(fDeclaration);
     expect(mainStatements, hasLength(2));
     _checkPrintLiteralInt(mainStatements[0], 1);
     _checkFunctionCall(mainStatements[1],
         resolutionMap.elementDeclaredByFunctionDeclaration(fDeclaration));
     expect(fStatements, hasLength(1));
     _checkPrintLiteralInt(fStatements[0], 2);
     // TODO(paulberry): now test incremental updates
   }
 
@@ skipping 44 matching lines @@
     }
     throw fail('No function declaration found with name "$name"');
   }
 
   NodeList<Statement> _getFunctionStatements(FunctionDeclaration function) {
     var body = function.functionExpression.body;
     expect(body, new isInstanceOf<BlockFunctionBody>());
     return (body as BlockFunctionBody).block.statements;
   }
 }