Add LimitedBinaryPrinter, tests and switch incremental generator to it.

pkg/kernel/lib/binary/ast_to_binary.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.
 library kernel.ast_to_binary;
 
 import '../ast.dart';
 import '../import_table.dart';
 import 'tag.dart';
 import 'dart:convert';
 import 'dart:typed_data';
 import 'dart:collection';
 
 /// Writes to a binary file.
 ///
 /// A [BinaryPrinter] can be used to write one file and must then be
 /// discarded.
 class BinaryPrinter extends Visitor {
   VariableIndexer _variableIndexer;
   LabelIndexer _labelIndexer;
   SwitchCaseIndexer _switchCaseIndexer;
   final TypeParameterIndexer _typeParameterIndexer = new TypeParameterIndexer();
-  final StringIndexer _stringIndexer = new StringIndexer();
+  final StringIndexer stringIndexer;
   final StringIndexer _sourceUriIndexer = new StringIndexer();
   Map<LibraryDependency, int> _libraryDependencyIndex =
       <LibraryDependency, int>{};
 
   final BufferedSink _sink;
 
   /// Create a printer that writes to the given [sink].
   ///
   /// The BinaryPrinter will use its own buffer, so the [sink] does not need
   /// one.
   ///
   /// If multiple binaries are to be written based on the same IR, a shared
   /// [globalIndexer] may be passed in to avoid rebuilding the same indices
   /// in every printer.
-  BinaryPrinter(Sink<List<int>> sink) : _sink = new BufferedSink(sink);
+  BinaryPrinter(Sink<List<int>> sink, {StringIndexer stringIndexer})
+      : _sink = new BufferedSink(sink),
+        stringIndexer = stringIndexer ?? new StringIndexer();
 
   void _flush() {
     _sink.flushAndDestroy();
   }
 
   void writeByte(int byte) {
     _sink.addByte(byte);
   }
 
   void writeBytes(List<int> bytes) {
@@ skipping 35 matching lines @@
       endOffset += entry.utf8Bytes.length;
       writeUInt30(endOffset);
     }
     // Write the UTF-8 encoded strings.
     for (var entry in indexer.entries) {
       writeBytes(entry.utf8Bytes);
     }
   }
 
   void writeStringReference(String string) {
-    writeUInt30(_stringIndexer[string]);
+    writeUInt30(stringIndexer[string]);
   }
 
   void writeStringReferenceList(List<String> strings) {
     writeList(strings, writeStringReference);
   }
 
   void writeUriReference(String string) {
     int index = _sourceUriIndexer[string];
     if (index == null) {
       // Assume file was loaded without linking. Bail out to empty string.
@@ skipping 26 matching lines @@
 
   void writeLinkTable(Program program) {
     List<CanonicalName> list = <CanonicalName>[];
     void visitCanonicalName(CanonicalName node) {
       node.index = list.length;
       list.add(node);
       node.children.forEach(visitCanonicalName);
     }
 
     for (var library in program.libraries) {
+      if (!shouldWriteLibraryCanonicalNames(library)) continue;
       visitCanonicalName(library.canonicalName);
     }
+    addCanonicalNamesForLinkTable(list);
     writeList(list, writeCanonicalNameEntry);
   }
 
+  /// Return `true` if all canonical names of the [library] should be written
+  /// into the link table.  If some libraries of the program are skipped,
+  /// then [addCanonicalNamesForLinkTable] should append all the additional
+  /// names referenced by the libraries that are written by [writeLibraries].
+  bool shouldWriteLibraryCanonicalNames(Library library) => true;
+
+  /// Append additional names for entities that are referenced by the
+  /// libraries that are written by [writeLibraries], but declared outside
+  /// of these libraries.
+  void addCanonicalNamesForLinkTable(List<CanonicalName> list) {}
+
   void writeCanonicalNameEntry(CanonicalName node) {
     var parent = node.parent;
     if (parent.isRoot) {
       writeByte(0);
     } else {
       writeUInt30(parent.index + 1);
     }
     writeStringReference(node.name);
   }
 
   void writeProgramFile(Program program) {
     program.computeCanonicalNames();
     writeMagicWord(Tag.ProgramFile);
-    _stringIndexer.scanProgram(program);
-    writeStringTable(_stringIndexer);
+    buildStringIndex(program);
+    writeStringTable(stringIndexer);
     writeUriToSource(program);
     writeLinkTable(program);
-    writeList(program.libraries, writeNode);
+    writeLibraries(program);
     writeMemberReference(program.mainMethod, allowNull: true);
     _flush();
   }
 
+  /// Fill the [stringIndexer] with all strings we are going to reference.
+  void buildStringIndex(Program program) {
+    stringIndexer.scanProgram(program);
+  }
+
+  /// Write all of some of the libraries of the [program].
+  void writeLibraries(Program program) {
+    writeList(program.libraries, writeNode);
+  }
+
   void writeUriToSource(Program program) {
     program.uriToSource.keys.forEach((uri) {
       _sourceUriIndexer.put(uri);
     });
     writeStringTable(_sourceUriIndexer);
     for (int i = 0; i < _sourceUriIndexer.entries.length; i++) {
       String uri = _sourceUriIndexer.entries[i].value;
       Source source =
           program.uriToSource[uri] ?? new Source(<int>[], const <int>[]);
       writeUtf8Bytes(source.source);
@@ skipping 905 matching lines @@
   final LibraryFilter predicate;
 
   LibraryFilteringBinaryPrinter(
       Sink<List<int>> sink, bool predicate(Library library))
       : predicate = predicate,
         super(sink);
 
   void writeProgramFile(Program program) {
     program.computeCanonicalNames();
     writeMagicWord(Tag.ProgramFile);
-    _stringIndexer.scanProgram(program);
-    writeStringTable(_stringIndexer);
+    stringIndexer.scanProgram(program);
+    writeStringTable(stringIndexer);
     writeUriToSource(program);
     writeLinkTable(program);
     writeList(program.libraries.where(predicate).toList(), writeNode);
     writeMemberReference(program.mainMethod, allowNull: true);
     _flush();
   }
 }
 
 class VariableIndexer {
   final Map<VariableDeclaration, int> index = <VariableDeclaration, int>{};
@@ skipping 86 matching lines @@
 class StringIndexer extends RecursiveVisitor<Null> {
   final List<StringTableEntry> entries = <StringTableEntry>[];
   final LinkedHashMap<String, int> index = new LinkedHashMap<String, int>();
 
   StringIndexer() {
     put('');
   }
 
   int get numberOfStrings => index.length;
 
-  void scanProgram(Node node) {
-    node.accept(this);
+  /// Scan all the [program] libraries and [finish] indexing.
+  void scanProgram(Program program) {
+    program.accept(this);
+    finish();
+  }
+
+  /// Scan the given library, but don't [finish] indexing yet.
+  void scanLibrary(Library library) {
+    library.accept(this);
+  }
+
+  /// Finish building of the index - sort and assign indices for entries.
+  void finish() {
     entries.sort();
     for (int i = 0; i < entries.length; ++i) {
       index[entries[i].value] = i;
     }
   }
 
   void visitCanonicalName(CanonicalName name) {
     put(name.name);
     name.children.forEach(visitCanonicalName);
   }
@@ skipping 193 matching lines @@
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     flushedLength += length;
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }