Add LimitedBinaryPrinter, tests and switch incremental generator to it.

pkg/front_end/lib/src/incremental_kernel_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 'dart:io';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/src/base/api_signature.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/translate_uri.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
+import 'package:front_end/src/incremental/limited_ast_to_binary.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
-import 'package:kernel/binary/ast_to_binary.dart';
 import 'package:kernel/kernel.dart' hide Source;
 
 dynamic unimplemented() {
   // TODO(paulberry): get rid of this.
   throw new UnimplementedError();
 }
 
 class ByteSink implements Sink<List<int>> {
   final BytesBuilder builder = new BytesBuilder();
 
@@ skipping 82 matching lines @@
 
       Program program = new Program(nameRoot: nameRoot);
 
       // Add affected libraries (with different signatures).
       for (_LibraryCycleResult result in results) {
         for (Library library in result.kernelLibraries) {
           Uri uri = library.importUri;
           if (_latestSignature[uri] != result.signature) {
             _latestSignature[uri] = result.signature;
             program.libraries.add(library);
+            library.parent = program;
           }
         }
       }
 
       // TODO(scheglov) Add libraries which import changed libraries.
 
       return new DeltaProgram(program);
     });
   }
 
@@ skipping 81 matching lines @@
 
       // Add newly compiled libraries into DILL.
       await appendNewDillLibraries(program);
 
       List<Library> kernelLibraries = program.libraries
           .where((library) => libraryUris.contains(library.importUri))
           .toList();
 
       _logger.run('Serialize ${kernelLibraries.length} libraries', () {
         program.unbindCanonicalNames();
+        program.uriToSource.clear();
         List<int> bytes = _writeProgramBytes(program, kernelLibraries.contains);
         _byteStore.put(kernelKey, bytes);
         _logger.writeln('Stored ${bytes.length} bytes.');
       });
 
       return new _LibraryCycleResult(cycle, signature, kernelLibraries);
     });
   }
 
   /// Compute exports scopes for a new strongly connected cycle of [libraries].
@@ skipping 39 matching lines @@
       for (var fileUri in _invalidatedFiles) {
         var file = await _fsState.getFile(fileUri);
         await file.refresh();
       }
       _invalidatedFiles.clear();
     });
   }
 
   List<int> _writeProgramBytes(Program program, bool filter(Library library)) {
     ByteSink byteSink = new ByteSink();
-    new LibraryFilteringBinaryPrinter(byteSink, filter)
-        .writeProgramFile(program);
+    new LimitedBinaryPrinter(byteSink, filter).writeProgramFile(program);
     return byteSink.builder.takeBytes();
   }
 }
 
 /// Compilation result for a library cycle.
 class _LibraryCycleResult {
   final LibraryCycle cycle;
 
   /// The signature of the result.
   ///
   /// Currently it is based on the full content of the transitive closure of
   /// the [cycle] files and all its dependencies.
   /// TODO(scheglov) Not used yet.
   /// TODO(scheglov) Use API signatures.
   /// TODO(scheglov) Or use tree shaking and compute signatures of outlines.
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   _LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }