More offsets in kernel

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 185 matching lines @@
       if (allowNull) {
         writeByte(Tag.NullReference);
       } else {
         throw 'Expected a member reference to be valid but was `null`.';
       }
     } else {
       node.acceptReference(this);
     }
   }
 
-  writeOffset(TreeNode node) {
+  writeOffset(TreeNode node, int offset) {
     // TODO(jensj): Delta-encoding.
     // File offset ranges from -1 and up,
     // but is here saved as unsigned (thus the +1)
-    writeUInt30(node.fileOffset + 1);
+    writeUInt30(offset + 1);
   }
 
   void visitClassReference(Class node) {
     var library = node.enclosingLibrary;
     writeByte(node.isMixinApplication
         ? Tag.MixinClassReference
         : Tag.NormalClassReference);
     writeLibraryReference(library);
     writeClassIndex(node);
   }
@@ skipping 62 matching lines @@
     writeList(annotations, writeAnnotation);
   }
 
   visitClass(Class node) {
     int flags = node.isAbstract ? 1 : 0;
     if (node.level == ClassLevel.Type) {
       flags |= 0x2;
     }
     if (node.isMixinApplication) {
       writeByte(Tag.MixinClass);
+      writeOffset(node, node.fileOffset);
       writeByte(flags);
       writeStringReference(node.name ?? '');
       writeUriReference(node.fileUri ?? '');
       writeAnnotationList(node.annotations);
       _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeNode(node.supertype);
       writeNode(node.mixedInType);
       writeNodeList(node.implementedTypes);
       writeNodeList(node.constructors);
       _typeParameterIndexer.exit(node.typeParameters);
     } else {
       writeByte(Tag.NormalClass);
+      writeOffset(node, node.fileOffset);
       writeByte(flags);
       writeStringReference(node.name ?? '');
       writeUriReference(node.fileUri ?? '');
       writeAnnotationList(node.annotations);
       _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeOptionalNode(node.supertype);
       writeNodeList(node.implementedTypes);
       writeNodeList(node.fields);
       writeNodeList(node.constructors);
       writeNodeList(node.procedures);
       _typeParameterIndexer.exit(node.typeParameters);
     }
   }
 
   static final Name _emptyName = new Name('');
 
   visitConstructor(Constructor node) {
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Constructor);
+    writeOffset(node, node.fileOffset);
+    writeOffset(node, node.fileEndOffset);
     writeByte(node.flags);
     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) {
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Procedure);
+    writeOffset(node, node.fileOffset);
+    writeOffset(node, node.fileEndOffset);
     writeByte(node.kind.index);
     writeByte(node.flags);
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeOptionalNode(node.function);
     _variableIndexer = null;
   }
 
   visitField(Field node) {
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Field);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
+    writeOffset(node, node.fileEndOffset);
     writeByte(node.flags);
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeNode(node.type);
     writeOptionalInferredValue(node.inferredValue);
     writeOptionalNode(node.initializer);
     _variableIndexer = null;
   }
 
@@ skipping 26 matching lines @@
 
   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.
     _typeParameterIndexer.enter(node.typeParameters);
+    writeOffset(node, node.fileOffset);
+    writeOffset(node, node.fileEndOffset);
     writeByte(node.asyncMarker.index);
+    writeByte(node.debuggable ? 1 : 0);
     writeNodeList(node.typeParameters);
     writeUInt30(node.requiredParameterCount);
     writeVariableDeclarationList(node.positionalParameters);
     writeVariableDeclarationList(node.namedParameters);
     writeNode(node.returnType);
     writeOptionalInferredValue(node.inferredReturnValue);
     writeOptionalNode(node.body);
     _labelIndexer = oldLabels;
     _switchCaseIndexer = oldCases;
     _typeParameterIndexer.exit(node.typeParameters);
     _variableIndexer.popScope();
   }
 
   visitInvalidExpression(InvalidExpression node) {
     writeByte(Tag.InvalidExpression);
   }
 
   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, node.fileOffset);
     } else {
       writeByte(Tag.VariableGet);
+      writeOffset(node, node.fileOffset);
       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, node.fileOffset);
       writeNode(node.value);
     } else {
       writeByte(Tag.VariableSet);
+      writeOffset(node, node.fileOffset);
       writeUInt30(_variableIndexer[node.variable]);
       writeNode(node.value);
     }
   }
 
   visitPropertyGet(PropertyGet node) {
     writeByte(Tag.PropertyGet);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeMemberReference(node.interfaceTarget, allowNull: true);
   }
 
   visitPropertySet(PropertySet node) {
     writeByte(Tag.PropertySet);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeNode(node.value);
     writeMemberReference(node.interfaceTarget, allowNull: true);
   }
 
   visitSuperPropertyGet(SuperPropertyGet node) {
     writeByte(Tag.SuperPropertyGet);
     writeName(node.name);
     writeMemberReference(node.interfaceTarget, allowNull: true);
@@ skipping 14 matching lines @@
 
   visitDirectPropertySet(DirectPropertySet node) {
     writeByte(Tag.DirectPropertySet);
     writeNode(node.receiver);
     writeMemberReference(node.target);
     writeNode(node.value);
   }
 
   visitStaticGet(StaticGet node) {
     writeByte(Tag.StaticGet);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeMemberReference(node.target);
   }
 
   visitStaticSet(StaticSet node) {
     writeByte(Tag.StaticSet);
     writeMemberReference(node.target);
     writeNode(node.value);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     writeByte(Tag.MethodInvocation);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeNode(node.arguments);
     writeMemberReference(node.interfaceTarget, allowNull: true);
   }
 
   visitSuperMethodInvocation(SuperMethodInvocation node) {
     writeByte(Tag.SuperMethodInvocation);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeName(node.name);
     writeNode(node.arguments);
     writeMemberReference(node.interfaceTarget, allowNull: true);
   }
 
   visitDirectMethodInvocation(DirectMethodInvocation node) {
     writeByte(Tag.DirectMethodInvocation);
     writeNode(node.receiver);
     writeMemberReference(node.target);
     writeNode(node.arguments);
   }
 
   visitStaticInvocation(StaticInvocation node) {
     writeByte(node.isConst ? Tag.ConstStaticInvocation : Tag.StaticInvocation);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeMemberReference(node.target);
     writeNode(node.arguments);
   }
 
   visitConstructorInvocation(ConstructorInvocation node) {
     writeByte(node.isConst
         ? Tag.ConstConstructorInvocation
         : Tag.ConstructorInvocation);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeMemberReference(node.target);
     writeNode(node.arguments);
   }
 
   visitArguments(Arguments node) {
     writeNodeList(node.types);
     writeNodeList(node.positional);
     writeNodeList(node.named);
   }
 
@@ skipping 27 matching lines @@
   visitConditionalExpression(ConditionalExpression node) {
     writeByte(Tag.ConditionalExpression);
     writeNode(node.condition);
     writeNode(node.then);
     writeNode(node.otherwise);
     writeOptionalNode(node.staticType);
   }
 
   visitStringConcatenation(StringConcatenation node) {
     writeByte(Tag.StringConcatenation);
+    writeOffset(node, node.fileOffset);
     writeNodeList(node.expressions);
   }
 
   visitIsExpression(IsExpression node) {
     writeByte(Tag.IsExpression);
+    writeOffset(node, node.fileOffset);
     writeNode(node.operand);
     writeNode(node.type);
   }
 
   visitAsExpression(AsExpression node) {
     writeByte(Tag.AsExpression);
     writeNode(node.operand);
     writeNode(node.type);
   }
 
@@ skipping 50 matching lines @@
   visitThisExpression(ThisExpression node) {
     writeByte(Tag.ThisExpression);
   }
 
   visitRethrow(Rethrow node) {
     writeByte(Tag.Rethrow);
   }
 
   visitThrow(Throw node) {
     writeByte(Tag.Throw);
-    writeOffset(node);
+    writeOffset(node, node.fileOffset);
     writeNode(node.expression);
   }
 
   visitListLiteral(ListLiteral node) {
     writeByte(node.isConst ? Tag.ConstListLiteral : Tag.ListLiteral);
     writeNode(node.typeArgument);
     writeNodeList(node.expressions);
   }
 
   visitMapLiteral(MapLiteral node) {
     writeByte(node.isConst ? Tag.ConstMapLiteral : Tag.MapLiteral);
+    writeOffset(node, node.fileOffset);
     writeNode(node.keyType);
     writeNode(node.valueType);
     writeNodeList(node.entries);
   }
 
   visitMapEntry(MapEntry node) {
     // Note: there is no tag on MapEntry
     writeNode(node.key);
     writeNode(node.value);
   }
@@ skipping 114 matching lines @@
 
   visitIfStatement(IfStatement node) {
     writeByte(Tag.IfStatement);
     writeNode(node.condition);
     writeNode(node.then);
     writeStatementOrEmpty(node.otherwise);
   }
 
   visitReturnStatement(ReturnStatement node) {
     writeByte(Tag.ReturnStatement);
+    writeOffset(node, node.fileOffset);
     writeOptionalNode(node.expression);
   }
 
   visitTryCatch(TryCatch node) {
     writeByte(Tag.TryCatch);
     writeNode(node.body);
     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, node.fileOffset);
     writeByte(node.flags);
     writeNode(node.expression);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     writeByte(Tag.VariableDeclaration);
     writeVariableDeclaration(node);
   }
 
   void writeVariableDeclaration(VariableDeclaration node) {
+    writeOffset(node, node.fileOffset);
     writeByte(node.flags);
     writeStringReference(node.name ?? '');
     writeNode(node.type);
     writeOptionalInferredValue(node.inferredValue);
     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);
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     writeByte(Tag.FunctionDeclaration);
+    writeOffset(node, node.fileOffset);
     writeVariableDeclaration(node.variable);
     writeNode(node.function);
   }
 
   visitBottomType(BottomType node) {
     writeByte(Tag.BottomType);
   }
 
   visitInvalidType(InvalidType node) {
     writeByte(Tag.InvalidType);
@@ skipping 344 matching lines @@
   void flush() {
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }