Hacky streaming of VariableGet

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 375 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.tempOffset);
     } else {
       writeByte(Tag.VariableGet);
       writeOffset(node.fileOffset);
+      writeUInt30(node.variable.tempOffset);
       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);
@@ skipping 257 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 90 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);
@@ skipping 50 matching lines @@
 
   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]) {
+    int length = _sink.flushedLength + _sink.length - (hasTag ? 1 : 0);

[Kevin Millikin (Google), 2017/04/05 08:59:57]

It seems better to move writing of the tag here so you have something like:

node.binaryPosition = ...;
if (hasTag) writeByte(Tag.VariableDeclaration);
writeOffset(node.fileOffset);
...

+    node.tempOffset = length;
     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 305 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));
   }
 }