More offsets in kernel

pkg/kernel/binary.md

 This file describes the binary format of Dart Kernel.
 
 Notation
 --------
 Bitmasks are described with the syntax:
 ```scala
     Byte flags (flag1, flag2, ..., flagN)
 ```
 where 'flag<N>' is the N-th least significant bit,
 (so flag1 is the least significant bit).
@@ skipping 178 matching lines @@
 // If the enclosing library is external, a class is either at type or
 // hierarchy level, depending on its isTypeLevel flag.
 // If the enclosing library is not external, a class is always at body level.
 //
 // See ClassLevel in ast.dart for the details of each loading level.
 
 abstract type Class extends Node {}
 
 type NormalClass extends Class {
   Byte tag = 2;
+  FileOffset fileOffset;
   Byte flags (isAbstract, isTypeLevel);
   StringReference name;
   // An absolute path URI to the .dart file from which the class was created.
   UriReference fileUri;
   List<Expression> annotations;
   List<TypeParameter> typeParameters;
   Option<InterfaceType> superClass;
   List<InterfaceType> implementedClasses;
   List<Field> fields;
   List<Constructor> constructors;
   List<Procedure> procedures;
 }
 
 type MixinClass extends Class {
   Byte tag = 3;
+  FileOffset fileOffset;
   Byte flags (isAbstract, isTypeLevel);
   StringReference name;
   // An absolute path URI to the .dart file from which the class was created.
   UriReference fileUri;
   List<Expression> annotations;
   List<TypeParameter> typeParameters;
   InterfaceType firstSuperClass;
   InterfaceType secondSuperClass;
   List<InterfaceType> implementedClasses;
   List<Constructor> constructors;
 }
 
 abstract type Member extends Node {}
 
 type Field extends Member {
   Byte tag = 4;
   FileOffset fileOffset;
+  FileOffset fileEndOffset;
   Byte flags (isFinal, isConst, isStatic);
   Name name;
   // An absolute path URI to the .dart file from which the field was created.
   UriReference fileUri;
   List<Expression> annotations;
   DartType type;
   Option<InferredValue> inferredValue;
   Option<Expression> initializer;
 }
 
 type Constructor extends Member {
   Byte tag = 5;
+  FileOffset fileOffset;
+  FileOffset fileEndOffset;
   Byte flags (isConst, isExternal);
   Name name;
   List<Expression> annotations;
   FunctionNode function;
   List<Initializer> initializers;
 }
 
 /*
 enum ProcedureKind {
   Method,
   Getter,
   Setter,
   Operator,
   Factory,
 }
 */
 
 type Procedure extends Member {
   Byte tag = 6;
+  FileOffset fileOffset;
+  FileOffset fileEndOffset;
   Byte kind; // Index into the ProcedureKind enum above.
   Byte flags (isStatic, isAbstract, isExternal, isConst);
   Name name;
   // An absolute path URI to the .dart file from which the class was created.
   UriReference fileUri;
   List<Expression> annotations;
   // Can only be absent if abstract, but tag is there anyway.
   Option<FunctionNode> function;
 }
 
@@ skipping 30 matching lines @@
 enum AsyncMarker {
   Sync,
   SyncStar,
   Async,
   AsyncStar
 }
 */
 
 type FunctionNode {
   // Note: there is no tag on FunctionNode.
+  FileOffset fileOffset;
+  FileOffset fileEndOffset;
   Byte asyncMarker; // Index into AsyncMarker above.
+  Byte debuggable; // 1 for yes, 0 for no
   List<TypeParameter> typeParameters;
   UInt requiredParameterCount;
   List<VariableDeclaration> positionalParameters;
   List<VariableDeclaration> namedParameters;
   DartType returnType;
   Option<InferredValue> inferredReturnValue;
   Option<Statement> body;
 }
 
 type VariableReference {
@@ skipping 20 matching lines @@
 }
 
 abstract type Expression extends Node {}
 
 type InvalidExpression extends Expression {
   Byte tag = 19;
 }
 
 type VariableGet extends Expression {
   Byte tag = 20;
+  FileOffset fileOffset;
   VariableReference variable;
 }
 
 type SpecializedVariableGet extends Expression {
   Byte tag = 128 + N; // Where 0 <= N < 8.
   // Equivalent to a VariableGet with index N.
+  FileOffset fileOffset;
 }
 
 type VariableSet extends Expression {
   Byte tag = 21;
+  FileOffset fileOffset;
   VariableReference variable;
   Expression value;
 }
 
 type SpecializedVariableSet extends Expression {
   Byte tag = 136 + N; // Where 0 <= N < 8.
+  FileOffset fileOffset;
   Expression value;
   // Equivalent to VariableSet with index N.
 }
 
 type PropertyGet extends Expression {
   Byte tag = 22;
   FileOffset fileOffset;
   Expression receiver;
   Name name;
   MemberReference interfaceTarget; // May be NullReference.
@@ skipping 132 matching lines @@
 type ConditionalExpression extends Expression {
   Byte tag = 35;
   Expression condition;
   Expression then;
   Expression otherwise;
   Option<DartType> staticType;
 }
 
 type StringConcatenation extends Expression {
   Byte tag = 36;
+  FileOffset fileOffset;
   List<Expression> expressions;
 }
 
 type IsExpression extends Expression {
   Byte tag = 37;
+  FileOffset fileOffset;
   Expression operand;
   DartType type;
 }
 
 type AsExpression extends Expression {
   Byte tag = 38;
   Expression operand;
   DartType type;
 }
 
@@ skipping 70 matching lines @@
 }
 
 type ConstListLiteral extends Expression {
   Byte tag = 58; // Note: tag is out of order.
   DartType typeArgument;
   List<Expression> values;
 }
 
 type MapLiteral extends Expression {
   Byte tag = 50;
+  FileOffset fileOffset;
   DartType keyType;
   DartType valueType;
   List<MapEntry> entries;
 }
 
 type ConstMapLiteral extends Expression {
   Byte tag = 59; // Note: tag is out of order.
   DartType keyType;
   DartType valueType;
   List<MapEntry> entries;
@@ skipping 126 matching lines @@
 
 type IfStatement extends Statement {
   Byte tag = 73;
   Expression condition;
   Statement then;
   Statement otherwise; // Empty statement if there was no else part.
 }
 
 type ReturnStatement extends Statement {
   Byte tag = 74;
+  FileOffset fileOffset;
   Option<Expression> expression;
 }
 
 type TryCatch extends Statement {
   Byte tag = 75;
   Statement body;
   List<Catch> catches;
 }
 
 type Catch {
   DartType guard;
   Option<VariableDeclaration> exception;
   Option<VariableDeclaration> stackTrace;
   Statement body;
 }
 
 type TryFinally extends Statement {
   Byte tag = 76;
   Statement body;
   Statement finalizer;
 }
 
 type YieldStatement extends Statement {
   Byte tag = 77;
+  FileOffset fileOffset;
   Byte flags (isYieldStar);
   Expression expression;
 }
 
 type VariableDeclarationStatement extends Statement {
   Byte tag = 78;
   VariableDeclaration variable;
 }
 
 type VariableDeclaration {
+  FileOffset fileOffset;
   Byte flags (isFinal, isConst);
   // For named parameters, this is the parameter name.
   // For other variables, the name is cosmetic, may be empty,
   // and is not necessarily unique.
   StringReference name;
   DartType type;
   Option<InferredValue> inferredValue;
 
   // For statements and for-loops, this is the initial value.
   // For optional parameters, this is the default value (if given).
   // In all other contexts, it must be Nothing.
   Option<Expression> initializer;
 }
 
 type FunctionDeclaration extends Statement {
   Byte tag = 79;
+  FileOffset fileOffset;
   // The variable binding the function.  The variable is in scope
   // within the function for use as a self-reference.
   // Some of the fields in the variable are redundant, but its presence here
   // simplifies the rule for variable indexing.
   VariableDeclaration variable;
   FunctionNode function;
 }
 
 abstract type DartType extends Node {}
 
@@ skipping 74 matching lines @@
 
 /* enum BaseClassKind { None, Exact, Subclass, Subtype, } */
 
 type InferredValue {
   ClassReference baseClass; // May be NullReference if kind = None.
   Byte kind; // Index into BaseClassKind.
   Byte valueBits; // See lib/type_propagation/type_propagation.dart
 }
 
 ```