[kernel] Delete most of the AST

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;
   final StringIndexer _sourceUriIndexer = new StringIndexer();
   Map<LibraryDependency, int> _libraryDependencyIndex =
       <LibraryDependency, int>{};
 
   final BufferedSink _sink;
 
+  int _binaryOffsetForSourceTable = -1;
+  int _binaryOffsetForLinkTable = -1;
+
   /// 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, {StringIndexer stringIndexer})
       : _sink = new BufferedSink(sink),
@@ skipping 19 matching lines @@
       writeByte((value >> 8) | 0x80);
       writeByte(value & 0xFF);
     } else {
       writeByte((value >> 24) | 0xC0);
       writeByte((value >> 16) & 0xFF);
       writeByte((value >> 8) & 0xFF);
       writeByte(value & 0xFF);
     }
   }
 
-  void writeMagicWord(int value) {
+  void writeUInt32(int value) {
     writeByte((value >> 24) & 0xFF);
     writeByte((value >> 16) & 0xFF);
     writeByte((value >> 8) & 0xFF);
     writeByte(value & 0xFF);
   }
 
   void writeUtf8Bytes(List<int> utf8Bytes) {
     writeUInt30(utf8Bytes.length);
     writeBytes(utf8Bytes);
   }
@@ skipping 45 matching lines @@
   void writeOptionalNode(Node node) {
     if (node == null) {
       writeByte(Tag.Nothing);
     } else {
       writeByte(Tag.Something);
       writeNode(node);
     }
   }
 
   void writeLinkTable(Program program) {
+    _binaryOffsetForLinkTable = _sink.flushedLength + _sink.length;
     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);
@@ skipping 23 matching lines @@
     if (parent.isRoot) {
       writeByte(0);
     } else {
       writeUInt30(parent.index + 1);
     }
     writeStringReference(node.name);
   }
 
   void writeProgramFile(Program program) {
     computeCanonicalNames(program);
-    writeMagicWord(Tag.ProgramFile);
+    writeUInt32(Tag.ProgramFile);
     buildStringIndex(program);
     writeStringTable(stringIndexer);
     writeUriToSource(program);
     writeLinkTable(program);
     writeLibraries(program);
     writeMemberReference(program.mainMethod, allowNull: true);
+    writeProgramIndex(program, program.libraries);
+
     _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 writeProgramIndex(Program program, List<Library> libraries) {
+    // Fixed-size ints at the end used as an index.
+    writeUInt32(_binaryOffsetForSourceTable);
+    writeUInt32(_binaryOffsetForLinkTable);
+
+    CanonicalName main = getCanonicalNameOfMember(program.mainMethod);
+    if (main == null) {
+      writeUInt32(0);
+    } else {
+      writeUInt32(main.index + 1);
+    }
+    for (Library library in libraries) {
+      writeUInt32(library.binaryOffset);
+    }
+    writeUInt32(libraries.length);
+  }
+
   void writeUriToSource(Program program) {
+    _binaryOffsetForSourceTable = _sink.flushedLength + _sink.length;
     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);
       List<int> lineStarts = source.lineStarts;
@@ skipping 65 matching lines @@
     // enclosing library.
     if (node.isPrivate) {
       writeLibraryReference(node.library);
     }
   }
 
   bool insideExternalLibrary = false;
 
   visitLibrary(Library node) {
     insideExternalLibrary = node.isExternal;
+    node.binaryOffset = _sink.flushedLength + _sink.length;
     writeByte(insideExternalLibrary ? 1 : 0);
     writeCanonicalNameReference(getCanonicalNameOfLibrary(node));
     writeStringReference(node.name ?? '');
     // TODO(jensj): We save (almost) the same URI twice.
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeLibraryDependencies(node);
     writeNodeList(node.typedefs);
     writeNodeList(node.classes);
     writeNodeList(node.fields);
@@ skipping 840 matching lines @@
 class LibraryFilteringBinaryPrinter extends BinaryPrinter {
   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);
+    writeUInt32(Tag.ProgramFile);
     stringIndexer.scanProgram(program);
     writeStringTable(stringIndexer);
     writeUriToSource(program);
     writeLinkTable(program);
-    writeList(program.libraries.where(predicate).toList(), writeNode);
+    final List<Library> filteredLibraries =
+        program.libraries.where(predicate).toList();
+    writeList(filteredLibraries, writeNode);
     writeMemberReference(program.mainMethod, allowNull: true);
+    writeProgramIndex(program, filteredLibraries);
+
     _flush();
   }
 }
 
 class VariableIndexer {
   final Map<VariableDeclaration, int> index = <VariableDeclaration, int>{};
   final List<int> scopes = <int>[];
   int stackHeight = 0;
 
   void declare(VariableDeclaration node) {
@@ skipping 311 matching lines @@
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     flushedLength += length;
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }