[kernel] Streaming ScopeBuilder

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 329 matching lines @@
     int abstactFlag = isAbstract ? 1 : 0;
     int levelFlags = (level.index - 1) << 1;
     return abstactFlag | levelFlags;
   }
 
   visitClass(Class node) {
     int flags = _encodeClassFlags(node.isAbstract, node.level);
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
+    node.binaryOffset = _sink.flushedLength + _sink.length;
     writeByte(Tag.Class);
     writeCanonicalNameReference(getCanonicalNameOfClass(node));
     writeOffset(node.fileOffset);
     writeByte(flags);
     writeStringReference(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     _typeParameterIndexer.enter(node.typeParameters);
     writeNodeList(node.typeParameters);
     writeOptionalNode(node.supertype);
@@ skipping 10 matching lines @@
   visitConstructor(Constructor node) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Constructor);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
     writeByte(node.flags);
+    assert(node.parent is Class);
+    Class parent = node.parent;
+    writeUInt30(parent.binaryOffset);
     writeName(node.name ?? _emptyName);
     writeAnnotationList(node.annotations);
     assert(node.function.typeParameters.isEmpty);
     writeNode(node.function);
     // Parameters are in scope in the initializers.
     _variableIndexer.restoreScope(node.function.positionalParameters.length +
         node.function.namedParameters.length);
     writeNodeList(node.initializers);
     _variableIndexer = null;
   }
 
   visitProcedure(Procedure node) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Procedure);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
     writeByte(node.kind.index);
     writeByte(node.flags);
+    if (node.parent is Class) {
+      Class parent = node.parent;
+      writeUInt30(parent.binaryOffset);
+    } else {
+      writeUInt30(0); // 0 is a valid offset, but not for a class.
+    }
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeOptionalNode(node.function);
     _variableIndexer = null;
   }
 
   visitField(Field node) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Field);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
     writeByte(node.flags);
+    if (node.parent is Class) {
+      Class parent = node.parent;
+      writeUInt30(parent.binaryOffset);
+    } else {
+      writeUInt30(0); // 0 is a valid offset, but not for a class.
+    }
     writeName(node.name);
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeNode(node.type);
     writeOptionalNode(node.initializer);
     _variableIndexer = null;
   }
 
   visitInvalidInitializer(InvalidInitializer node) {
     writeByte(Tag.InvalidInitializer);
@@ skipping 12 matching lines @@
   }
 
   visitRedirectingInitializer(RedirectingInitializer node) {
     writeByte(Tag.RedirectingInitializer);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitLocalInitializer(LocalInitializer node) {
     writeByte(Tag.LocalInitializer);
-    writeVariableDeclaration(node.variable, false);
+    writeVariableDeclaration(node.variable);
   }
 
   visitFunctionNode(FunctionNode node) {
+    writeByte(Tag.FunctionNode);
     assert(_variableIndexer != null);
     _variableIndexer.pushScope();
     var oldLabels = _labelIndexer;
     _labelIndexer = new LabelIndexer();
     var oldCases = _switchCaseIndexer;
     _switchCaseIndexer = new SwitchCaseIndexer();
     // Note: FunctionNode has no tag.
     _typeParameterIndexer.enter(node.typeParameters);
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
@@ skipping 16 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);
+      writeUInt30(node.variable.binaryOffsetNoTag);
     } else {
       writeByte(Tag.VariableGet);
       writeOffset(node.fileOffset);
-      writeUInt30(node.variable.binaryOffset);
+      writeUInt30(node.variable.binaryOffsetNoTag);
       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);
+      writeUInt30(node.variable.binaryOffsetNoTag);
       writeNode(node.value);
     } else {
       writeByte(Tag.VariableSet);
       writeOffset(node.fileOffset);
-      writeUInt30(node.variable.binaryOffset);
+      writeUInt30(node.variable.binaryOffsetNoTag);
       writeUInt30(_variableIndexer[node.variable]);
       writeNode(node.value);
     }
   }
 
   visitPropertyGet(PropertyGet node) {
     writeByte(Tag.PropertyGet);
     writeOffset(node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
@@ skipping 243 matching lines @@
     writeNode(node.operand);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     writeByte(Tag.FunctionExpression);
     writeNode(node.function);
   }
 
   visitLet(Let node) {
     writeByte(Tag.Let);
-    writeVariableDeclaration(node.variable, false);
+    writeVariableDeclaration(node.variable);
     writeNode(node.body);
     --_variableIndexer.stackHeight;
   }
 
   visitLoadLibrary(LoadLibrary node) {
     writeByte(Tag.LoadLibrary);
     writeLibraryDependencyReference(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, false);
+    writeVariableDeclaration(node.variable);
     writeNode(node.iterable);
     writeNode(node.body);
     _variableIndexer.popScope();
   }
 
   visitSwitchStatement(SwitchStatement node) {
     _switchCaseIndexer.enter(node);
     writeByte(Tag.SwitchStatement);
     writeNode(node.expression);
     writeNodeList(node.cases);
@@ skipping 60 matching lines @@
   }
 
   visitYieldStatement(YieldStatement node) {
     writeByte(Tag.YieldStatement);
     writeOffset(node.fileOffset);
     writeByte(node.flags);
     writeNode(node.expression);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
-    writeVariableDeclaration(node, true);
+    writeByte(Tag.VariableDeclaration);
+    writeVariableDeclaration(node);
   }
 
-  void writeVariableDeclaration(VariableDeclaration node,
-      [bool hasTag = false]) {
-    node.binaryOffset = _sink.flushedLength + _sink.length;
-    if (hasTag) writeByte(Tag.VariableDeclaration);
+  void writeVariableDeclaration(VariableDeclaration node) {
+    node.binaryOffsetNoTag = _sink.flushedLength + _sink.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, false);
+      writeVariableDeclaration(node);
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     writeByte(Tag.FunctionDeclaration);
     writeOffset(node.fileOffset);
-    writeVariableDeclaration(node.variable, false);
+    writeVariableDeclaration(node.variable);
     writeNode(node.function);
   }
 
   visitBottomType(BottomType node) {
     writeByte(Tag.BottomType);
   }
 
   visitInvalidType(InvalidType node) {
     writeByte(Tag.InvalidType);
   }
@@ skipping 426 matching lines @@
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     flushedLength += length;
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }