More offsets in kernel

pkg/kernel/lib/binary/ast_from_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_from_binary;
 
 import '../ast.dart';
 import 'tag.dart';
 import 'loader.dart';
 import 'dart:convert';
 import 'package:kernel/transformations/flags.dart';
@@ skipping 303 matching lines @@
         break;
       case Tag.MixinClass:
         readMixinClass(node);
         break;
       default:
         throw fail('Invalid class tag: $tag');
     }
   }
 
   void readNormalClass(Class node) {
+    node.fileOffset = readOffset();
     int flags = readByte();
     node.isAbstract = flags & 0x1 != 0;
     node.level = _currentLibrary.isExternal
         ? (flags & 0x2 != 0) ? ClassLevel.Type : ClassLevel.Hierarchy
         : ClassLevel.Body;
     node.name = readStringOrNullIfEmpty();
     node.fileUri = readUriReference();
     node.annotations = readAnnotationList(node);
     debugPath.add(node.name ?? 'normal-class');
     readAndPushTypeParameterList(node.typeParameters, node);
     node.supertype = readSupertypeOption();
     _fillNonTreeNodeList(node.implementedTypes, readSupertype);
     _fillLazilyLoadedList(node.fields, (int tag, int index) {
       readField(loader.getClassMemberReference(node, tag, index), tag);
     });
     _fillLazilyLoadedList(node.constructors, (int tag, int index) {
       readConstructor(loader.getClassMemberReference(node, tag, index), tag);
     });
     _fillLazilyLoadedList(node.procedures, (int tag, int index) {
       readProcedure(loader.getClassMemberReference(node, tag, index), tag);
     });
     typeParameterStack.length = 0;
     debugPath.removeLast();
   }
 
   void readMixinClass(Class node) {
+    node.fileOffset = readOffset();
     int flags = readByte();
     node.isAbstract = flags & 0x1 != 0;
     node.level = _currentLibrary.isExternal
         ? (flags & 0x2 != 0) ? ClassLevel.Type : ClassLevel.Hierarchy
         : ClassLevel.Body;
     node.name = readStringOrNullIfEmpty();
     node.fileUri = readUriReference();
     node.annotations = readAnnotationList(node);
     debugPath.add(node.name ?? 'mixin-class');
     readAndPushTypeParameterList(node.typeParameters, node);
@@ skipping 17 matching lines @@
   void addTransformerFlag(int flags) {
     _transformerFlags |= flags;
   }
 
   void readField(Field node, int tag) {
     // Note: as with readProcedure and readConstructor, the tag parameter
     // is unused, but we pass it in to clarify that the tag has already been
     // consumed from the input.
     assert(tag == Tag.Field);
     node.fileOffset = readOffset();
+    node.fileEndOffset = readOffset();
     node.flags = readByte();
     node.name = readName();
     node.fileUri = readUriReference();
     node.annotations = readAnnotationList(node);
     debugPath.add(node.name?.name ?? 'field');
     node.type = readDartType();
     node.inferredValue = readOptionalInferredValue();
     node.initializer = readExpressionOption();
     node.initializer?.parent = node;
     node.transformerFlags = getAndResetTransformerFlags();
     debugPath.removeLast();
   }
 
   void readConstructor(Constructor node, int tag) {
     assert(tag == Tag.Constructor);
+    node.fileOffset = readOffset();
+    node.fileEndOffset = readOffset();
     node.flags = readByte();
     node.name = readName();
     node.annotations = readAnnotationList(node);
     debugPath.add(node.name?.name ?? 'constructor');
     node.function = readFunctionNode()..parent = node;
     pushVariableDeclarations(node.function.positionalParameters);
     pushVariableDeclarations(node.function.namedParameters);
     _fillTreeNodeList(node.initializers, readInitializer, node);
     variableStack.length = 0;
     node.transformerFlags = getAndResetTransformerFlags();
     debugPath.removeLast();
   }
 
   void readProcedure(Procedure node, int tag) {
     assert(tag == Tag.Procedure);
+    node.fileOffset = readOffset();
+    node.fileEndOffset = readOffset();
     int kindIndex = readByte();
     node.kind = ProcedureKind.values[kindIndex];
     node.flags = readByte();
     node.name = readName();
     node.fileUri = readUriReference();
     node.annotations = readAnnotationList(node);
     debugPath.add(node.name?.name ?? 'procedure');
     node.function = readFunctionNodeOption();
     node.function?.parent = node;
     node.transformerFlags = getAndResetTransformerFlags();
@@ skipping 17 matching lines @@
       default:
         throw fail('Invalid initializer tag: $tag');
     }
   }
 
   FunctionNode readFunctionNodeOption() {
     return readAndCheckOptionTag() ? readFunctionNode() : null;
   }
 
   FunctionNode readFunctionNode() {
+    int offset = readOffset();
+    int endOffset = readOffset();
     AsyncMarker asyncMarker = AsyncMarker.values[readByte()];
+    bool debuggable = readByte() == 1 ? true : false;
     int typeParameterStackHeight = typeParameterStack.length;
     var typeParameters = readAndPushTypeParameterList();
     var requiredParameterCount = readUInt();
     int variableStackHeight = variableStack.length;
     var positional = readAndPushVariableDeclarationList();
     var named = readAndPushVariableDeclarationList();
     var returnType = readDartType();
     var inferredReturnValue = readOptionalInferredValue();
     int oldLabelStackBase = labelStackBase;
     labelStackBase = labelStack.length;
     var body = readStatementOption();
     labelStackBase = oldLabelStackBase;
     variableStack.length = variableStackHeight;
     typeParameterStack.length = typeParameterStackHeight;
     return new FunctionNode(body,
         typeParameters: typeParameters,
         requiredParameterCount: requiredParameterCount,
         positionalParameters: positional,
         namedParameters: named,
         returnType: returnType,
         inferredReturnValue: inferredReturnValue,
-        asyncMarker: asyncMarker);
+        asyncMarker: asyncMarker)
+      ..fileOffset = offset
+      ..fileEndOffset = endOffset
+      ..debuggable = debuggable;
   }
 
   void pushVariableDeclaration(VariableDeclaration variable) {
     variableStack.add(variable);
   }
 
   void pushVariableDeclarations(List<VariableDeclaration> variables) {
     variableStack.addAll(variables);
   }
 
@@ skipping 26 matching lines @@
 
   Expression readExpression() {
     int tagByte = readByte();
     int tag = tagByte & Tag.SpecializedTagHighBit == 0
         ? tagByte
         : (tagByte & Tag.SpecializedTagMask);
     switch (tag) {
       case Tag.InvalidExpression:
         return new InvalidExpression();
       case Tag.VariableGet:
-        return new VariableGet(readVariableReference(), readDartTypeOption());
+        int offset = readOffset();
+        return new VariableGet(readVariableReference(), readDartTypeOption())
+          ..fileOffset = offset;
       case Tag.SpecializedVariableGet:
         int index = tagByte & Tag.SpecializedPayloadMask;
-        return new VariableGet(variableStack[index]);
+        int offset = readOffset();
+        return new VariableGet(variableStack[index])..fileOffset = offset;
       case Tag.VariableSet:
-        return new VariableSet(readVariableReference(), readExpression());
+        int offset = readOffset();
+        return new VariableSet(readVariableReference(), readExpression())
+          ..fileOffset = offset;
       case Tag.SpecializedVariableSet:
         int index = tagByte & Tag.SpecializedPayloadMask;
-        return new VariableSet(variableStack[index], readExpression());
+        int offset = readOffset();
+        return new VariableSet(variableStack[index], readExpression())
+          ..fileOffset = offset;
       case Tag.PropertyGet:
         int offset = readOffset();
         return new PropertyGet(
             readExpression(), readName(), readMemberReference(allowNull: true))
           ..fileOffset = offset;
       case Tag.PropertySet:
         int offset = readOffset();
         return new PropertySet(readExpression(), readName(), readExpression(),
             readMemberReference(allowNull: true))..fileOffset = offset;
       case Tag.SuperPropertyGet:
@@ skipping 48 matching lines @@
             isConst: true)..fileOffset = offset;
       case Tag.Not:
         return new Not(readExpression());
       case Tag.LogicalExpression:
         return new LogicalExpression(readExpression(),
             logicalOperatorToString(readByte()), readExpression());
       case Tag.ConditionalExpression:
         return new ConditionalExpression(readExpression(), readExpression(),
             readExpression(), readDartTypeOption());
       case Tag.StringConcatenation:
-        return new StringConcatenation(readExpressionList());
+        int offset = readOffset();
+        return new StringConcatenation(readExpressionList())
+          ..fileOffset = offset;
       case Tag.IsExpression:
-        return new IsExpression(readExpression(), readDartType());
+        int offset = readOffset();
+        return new IsExpression(readExpression(), readDartType())
+          ..fileOffset = offset;
       case Tag.AsExpression:
         return new AsExpression(readExpression(), readDartType());
       case Tag.StringLiteral:
         return new StringLiteral(readStringReference());
       case Tag.SpecializedIntLiteral:
         int biasedValue = tagByte & Tag.SpecializedPayloadMask;
         return new IntLiteral(biasedValue - Tag.SpecializedIntLiteralBias);
       case Tag.PositiveIntLiteral:
         return new IntLiteral(readUInt());
       case Tag.NegativeIntLiteral:
@@ skipping 21 matching lines @@
         return new Throw(readExpression())..fileOffset = offset;
       case Tag.ListLiteral:
         var typeArgument = readDartType();
         return new ListLiteral(readExpressionList(),
             typeArgument: typeArgument, isConst: false);
       case Tag.ConstListLiteral:
         var typeArgument = readDartType();
         return new ListLiteral(readExpressionList(),
             typeArgument: typeArgument, isConst: true);
       case Tag.MapLiteral:
+        int offset = readOffset();
         var keyType = readDartType();
         var valueType = readDartType();
         return new MapLiteral(readMapEntryList(),
-            keyType: keyType, valueType: valueType, isConst: false);
+            keyType: keyType,
+            valueType: valueType,
+            isConst: false)..fileOffset = offset;
       case Tag.ConstMapLiteral:
+        int offset = readOffset();
         var keyType = readDartType();
         var valueType = readDartType();
         return new MapLiteral(readMapEntryList(),
-            keyType: keyType, valueType: valueType, isConst: true);
+            keyType: keyType,
+            valueType: valueType,
+            isConst: true)..fileOffset = offset;
       case Tag.AwaitExpression:
         return new AwaitExpression(readExpression());
       case Tag.FunctionExpression:
         return new FunctionExpression(readFunctionNode());
       case Tag.Let:
         var variable = readVariableDeclaration();
         int stackHeight = variableStack.length;
         pushVariableDeclaration(variable);
         var body = readExpression();
         variableStack.length = stackHeight;
@@ skipping 85 matching lines @@
         }
         switchCaseStack.length -= count;
         return new SwitchStatement(expression, cases);
       case Tag.ContinueSwitchStatement:
         int index = readUInt();
         return new ContinueSwitchStatement(switchCaseStack[index]);
       case Tag.IfStatement:
         return new IfStatement(
             readExpression(), readStatement(), readStatementOrNullIfEmpty());
       case Tag.ReturnStatement:
-        return new ReturnStatement(readExpressionOption());
+        int offset = readOffset();
+        return new ReturnStatement(readExpressionOption())..fileOffset = offset;
       case Tag.TryCatch:
         return new TryCatch(readStatement(), readCatchList());
       case Tag.TryFinally:
         return new TryFinally(readStatement(), readStatement());
       case Tag.YieldStatement:
+        int offset = readOffset();
         int flags = readByte();
         return new YieldStatement(readExpression(),
             isYieldStar: flags & YieldStatement.FlagYieldStar != 0,
-            isNative: flags & YieldStatement.FlagNative != 0);
+            isNative: flags & YieldStatement.FlagNative != 0)
+          ..fileOffset = offset;
       case Tag.VariableDeclaration:
         var variable = readVariableDeclaration();
         variableStack.add(variable); // Will be popped by the enclosing scope.
         return variable;
       case Tag.FunctionDeclaration:
+        int offset = readOffset();
         var variable = readVariableDeclaration();
         variableStack.add(variable); // Will be popped by the enclosing scope.
         var function = readFunctionNode();
-        return new FunctionDeclaration(variable, function);
+        return new FunctionDeclaration(variable, function)..fileOffset = offset;
       default:
         throw fail('Invalid statement tag: $tag');
     }
   }
 
   List<Catch> readCatchList() {
     return new List<Catch>.generate(readUInt(), (i) => readCatch());
   }
 
   Catch readCatch() {
@@ skipping 131 matching lines @@
     return readAndCheckOptionTag() ? readAndPushVariableDeclaration() : null;
   }
 
   VariableDeclaration readAndPushVariableDeclaration() {
     var variable = readVariableDeclaration();
     variableStack.add(variable);
     return variable;
   }
 
   VariableDeclaration readVariableDeclaration() {
+    int offset = readOffset();
     int flags = readByte();
     return new VariableDeclaration(readStringOrNullIfEmpty(),
         type: readDartType(),
         inferredValue: readOptionalInferredValue(),
         initializer: readExpressionOption(),
         isFinal: flags & 0x1 != 0,
-        isConst: flags & 0x2 != 0);
+        isConst: flags & 0x2 != 0)..fileOffset = offset;
   }
 
   int readOffset() {
     // Offset is saved as unsigned,
     // but actually ranges from -1 and up (thus the -1)
     return readUInt() - 1;
   }
 }