[kernel] [partial] Streaming of kernel binary without AST nodes

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';
@@ skipping 386 matching lines @@
   }
 
   visitRedirectingInitializer(RedirectingInitializer node) {
     writeByte(Tag.RedirectingInitializer);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitLocalInitializer(LocalInitializer node) {
     writeByte(Tag.LocalInitializer);
-    writeVariableDeclaration(node.variable);
+    writeVariableDeclaration(node.variable, false);
   }
 
   visitFunctionNode(FunctionNode node) {
     assert(_variableIndexer != null);
     _variableIndexer.pushScope();
     var oldLabels = _labelIndexer;
     _labelIndexer = new LabelIndexer();
     var oldCases = _switchCaseIndexer;
     _switchCaseIndexer = new SwitchCaseIndexer();
     // Note: FunctionNode has no tag.
@@ skipping 19 matching lines @@
   }
 
   visitVariableGet(VariableGet node) {
     assert(_variableIndexer != null);
     int index = _variableIndexer[node.variable];
     assert(index != null);
     if (index & Tag.SpecializedPayloadMask == index &&
         node.promotedType == null) {
       writeByte(Tag.SpecializedVariableGet + index);
       writeOffset(node.fileOffset);
+      writeUInt30(node.variable.binaryOffset);
     } else {
       writeByte(Tag.VariableGet);
       writeOffset(node.fileOffset);
+      writeUInt30(node.variable.binaryOffset);
       writeUInt30(_variableIndexer[node.variable]);
       writeOptionalNode(node.promotedType);
     }
   }
 
   visitVariableSet(VariableSet node) {
     assert(_variableIndexer != null);
     int index = _variableIndexer[node.variable];
     if (index & Tag.SpecializedPayloadMask == index) {
       writeByte(Tag.SpecializedVariableSet + index);
       writeOffset(node.fileOffset);
+      writeUInt30(node.variable.binaryOffset);
       writeNode(node.value);
     } else {
       writeByte(Tag.VariableSet);
       writeOffset(node.fileOffset);
+      writeUInt30(node.variable.binaryOffset);
       writeUInt30(_variableIndexer[node.variable]);
       writeNode(node.value);
     }
   }
 
   visitPropertyGet(PropertyGet node) {
     writeByte(Tag.PropertyGet);
     writeOffset(node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
@@ skipping 84 matching lines @@
   visitConstructorInvocation(ConstructorInvocation node) {
     writeByte(node.isConst
         ? Tag.ConstConstructorInvocation
         : Tag.ConstructorInvocation);
     writeOffset(node.fileOffset);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitArguments(Arguments node) {
+    writeUInt30(node.positional.length + node.named.length);
     writeNodeList(node.types);
     writeNodeList(node.positional);
     writeNodeList(node.named);
   }
 
   visitNamedExpression(NamedExpression node) {
     writeStringReference(node.name);
     writeNode(node.value);
   }
 
@@ skipping 138 matching lines @@
     writeNode(node.operand);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     writeByte(Tag.FunctionExpression);
     writeNode(node.function);
   }
 
   visitLet(Let node) {
     writeByte(Tag.Let);
-    writeVariableDeclaration(node.variable);
+    writeVariableDeclaration(node.variable, false);
     writeNode(node.body);
     --_variableIndexer.stackHeight;
   }
 
   visitLoadLibrary(LoadLibrary node) {
     writeByte(Tag.LoadLibrary);
     writeDeferredImportReference(node.import);
   }
 
   visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
@@ skipping 97 matching lines @@
     writeOptionalNode(node.condition);
     writeNodeList(node.updates);
     writeNode(node.body);
     _variableIndexer.popScope();
   }
 
   visitForInStatement(ForInStatement node) {
     _variableIndexer.pushScope();
     writeByte(node.isAsync ? Tag.AsyncForInStatement : Tag.ForInStatement);
     writeOffset(node.fileOffset);
-    writeVariableDeclaration(node.variable);
+    writeVariableDeclaration(node.variable, false);
     writeNode(node.iterable);
     writeNode(node.body);
     _variableIndexer.popScope();
   }
 
   visitSwitchStatement(SwitchStatement node) {
     _switchCaseIndexer.enter(node);
     writeByte(Tag.SwitchStatement);
     writeNode(node.expression);
     writeNodeList(node.cases);
     _switchCaseIndexer.exit(node);
   }
 
   visitSwitchCase(SwitchCase node) {
     // Note: there is no tag on SwitchCase.
-    writeNodeList(node.expressions);
-    node.expressionOffsets.forEach(writeOffset);
+    int length = node.expressions.length;
+    writeUInt30(length);
+    for (int i = 0; i < length; ++i) {
+      writeOffset(node.expressionOffsets[i]);
+      writeNode(node.expressions[i]);
+    }
     writeByte(node.isDefault ? 1 : 0);
     writeNode(node.body);
   }
 
   visitContinueSwitchStatement(ContinueSwitchStatement node) {
     writeByte(Tag.ContinueSwitchStatement);
     writeUInt30(_switchCaseIndexer[node.target]);
   }
 
   visitIfStatement(IfStatement node) {
     writeByte(Tag.IfStatement);
     writeNode(node.condition);
     writeNode(node.then);
     writeStatementOrEmpty(node.otherwise);
   }
 
   visitReturnStatement(ReturnStatement node) {
     writeByte(Tag.ReturnStatement);
     writeOffset(node.fileOffset);
     writeOptionalNode(node.expression);
   }
 
   visitTryCatch(TryCatch node) {
     writeByte(Tag.TryCatch);
     writeNode(node.body);
+    if (node.catches.any((Catch c) => c.stackTrace != null)) {
+      // at least one catch needs the stack trace.
+      writeByte(1);
+    } else {
+      // no catch needs the stack trace.
+      writeByte(0);
+    }
     writeNodeList(node.catches);
   }
 
   visitCatch(Catch node) {
     // Note: there is no tag on Catch.
     _variableIndexer.pushScope();
     writeNode(node.guard);
     writeOptionalVariableDeclaration(node.exception);
     writeOptionalVariableDeclaration(node.stackTrace);
     writeNode(node.body);
     _variableIndexer.popScope();
   }
 
   visitTryFinally(TryFinally node) {
     writeByte(Tag.TryFinally);
     writeNode(node.body);
     writeNode(node.finalizer);
   }
 
   visitYieldStatement(YieldStatement node) {
     writeByte(Tag.YieldStatement);
     writeOffset(node.fileOffset);
     writeByte(node.flags);
     writeNode(node.expression);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
-    writeByte(Tag.VariableDeclaration);
-    writeVariableDeclaration(node);
+    writeVariableDeclaration(node, true);
   }
 
-  void writeVariableDeclaration(VariableDeclaration node) {
+  void writeVariableDeclaration(VariableDeclaration node,
+      [bool hasTag = false]) {
+    node.binaryOffset = _sink.flushedLength + _sink.length;
+    if (hasTag) writeByte(Tag.VariableDeclaration);
     writeOffset(node.fileOffset);
     writeOffset(node.fileEqualsOffset);
     writeByte(node.flags);
     writeStringReference(node.name ?? '');
     writeNode(node.type);
     writeOptionalNode(node.initializer);
     // Declare the variable after its initializer. It is not in scope in its
     // own initializer.
     _variableIndexer.declare(node);
   }
 
   void writeVariableDeclarationList(List<VariableDeclaration> nodes) {
     writeList(nodes, writeVariableDeclaration);
   }
 
   void writeOptionalVariableDeclaration(VariableDeclaration node) {
     if (node == null) {
       writeByte(Tag.Nothing);
     } else {
       writeByte(Tag.Something);
-      writeVariableDeclaration(node);
+      writeVariableDeclaration(node, false);
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     writeByte(Tag.FunctionDeclaration);
     writeOffset(node.fileOffset);
-    writeVariableDeclaration(node.variable);
+    writeVariableDeclaration(node.variable, false);
     writeNode(node.function);
   }
 
   visitBottomType(BottomType node) {
     writeByte(Tag.BottomType);
   }
 
   visitInvalidType(InvalidType node) {
     writeByte(Tag.InvalidType);
   }
@@ skipping 33 matching lines @@
         node.typeParameters.isEmpty &&
         node.namedParameters.isEmpty) {
       writeByte(Tag.SimpleFunctionType);
       writeNodeList(node.positionalParameters);
       writeNode(node.returnType);
     } else {
       writeByte(Tag.FunctionType);
       _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeUInt30(node.requiredParameterCount);
+      writeUInt30(
+          node.positionalParameters.length + node.namedParameters.length);
       writeNodeList(node.positionalParameters);
       writeNodeList(node.namedParameters);
       writeNode(node.returnType);
       _typeParameterIndexer.exit(node.typeParameters);
     }
   }
 
   visitNamedType(NamedType node) {
     writeStringReference(node.name);
     writeNode(node.type);
   }
 
   visitTypeParameterType(TypeParameterType node) {
     writeByte(Tag.TypeParameterType);
     writeUInt30(_typeParameterIndexer[node.parameter]);
+    writeUInt30(node.parameter.binaryOffset);
     writeOptionalNode(node.bound);
   }
 
   visitVectorType(VectorType node) {
     writeByte(Tag.VectorType);
   }
 
   visitTypedefType(TypedefType node) {
     writeByte(Tag.TypedefType);
     writeReference(node.typedefReference);
     writeNodeList(node.typeArguments);
   }
 
   visitTypeParameter(TypeParameter node) {
+    node.binaryOffset = _sink.flushedLength + _sink.length;
     writeStringReference(node.name ?? '');
     writeNode(node.bound);
   }
 
   defaultNode(Node node) {
     throw 'Unsupported node: $node';
   }
 }
 
 typedef bool LibraryFilter(Library _);
@@ skipping 260 matching lines @@
   }
 }
 
 /// Puts a buffer in front of a [Sink<List<int>>].
 class BufferedSink {
   static const int SIZE = 100000;
   static const int SMALL = 10000;
   final Sink<List<int>> _sink;
   Uint8List _buffer = new Uint8List(SIZE);
   int length = 0;
+  int flushedLength = 0;
 
   BufferedSink(this._sink);
 
   void addByte(int byte) {
     _buffer[length++] = byte;
     if (length == SIZE) {
       _sink.add(_buffer);
       _buffer = new Uint8List(SIZE);
       length = 0;
+      flushedLength += SIZE;
     }
   }
 
   void addBytes(List<int> bytes) {
     // Avoid copying a large buffer into the another large buffer. Also, if
     // the bytes buffer is too large to fit in our own buffer, just emit both.
     if (length + bytes.length < SIZE &&
         (bytes.length < SMALL || length < SMALL)) {
       if (length == 0) {
         _sink.add(bytes);
+        flushedLength += bytes.length;
       } else {
         _buffer.setRange(length, length + bytes.length, bytes);
         length += bytes.length;
       }
     } else if (bytes.length < SMALL) {
       // Flush as much as we can in the current buffer.
       _buffer.setRange(length, SIZE, bytes);
       _sink.add(_buffer);
       // Copy over the remainder into a new buffer. It is guaranteed to fit
       // because the input byte array is small.
       int alreadyEmitted = SIZE - length;
       int remainder = bytes.length - alreadyEmitted;
       _buffer = new Uint8List(SIZE);
       _buffer.setRange(0, remainder, bytes, alreadyEmitted);
       length = remainder;
+      flushedLength += SIZE;
     } else {
       _sink.add(_buffer.sublist(0, length));
       _sink.add(bytes);
       _buffer = new Uint8List(SIZE);
+      flushedLength += length;
+      flushedLength += bytes.length;
       length = 0;
     }
   }
 
   void flush() {
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
+    flushedLength += length;
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }