[kernel] [partial] Streaming of kernel binary without AST nodes

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 328 matching lines @@
 
 abstract type Expression extends Node {}
 
 type InvalidExpression extends Expression {
   Byte tag = 19;
 }
 
 type VariableGet extends Expression {
   Byte tag = 20;
   FileOffset fileOffset;
+  UInt variableDeclarationPosition; // Byte offset in the binary for the variable declaration.
   VariableReference variable;
 }
 
 type SpecializedVariableGet extends Expression {
   Byte tag = 128 + N; // Where 0 <= N < 8.
   // Equivalent to a VariableGet with index N.
   FileOffset fileOffset;
+  UInt variableDeclarationPosition; // Byte offset in the binary for the variable declaration.
 }
 
 type VariableSet extends Expression {
   Byte tag = 21;
   FileOffset fileOffset;
+  UInt variableDeclarationPosition; // Byte offset in the binary for the variable declaration.
   VariableReference variable;
   Expression value;
 }
 
 type SpecializedVariableSet extends Expression {
   Byte tag = 136 + N; // Where 0 <= N < 8.
   FileOffset fileOffset;
+  UInt variableDeclarationPosition; // Byte offset in the binary for the variable declaration.
   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 44 matching lines @@
 
 type StaticSet extends Expression {
   Byte tag = 27;
   FileOffset fileOffset;
   MemberReference target;
   Expression value;
 }
 
 type Arguments {
   // Note: there is no tag on Arguments.
+  UInt numArguments; // equals positional.length + named.length
   List<DartType> types;
   List<Expression> positional;
   List<NamedExpression> named;
 }
 
 type NamedExpression {
   // Note: there is no tag on NamedExpression.
   StringReference name;
   Expression value;
 }
@@ skipping 331 matching lines @@
   Expression iterable;
   Statement body;
 }
 
 type SwitchStatement extends Statement {
   Byte tag = 71;
   Expression expression;
   List<SwitchCase> cases;
 }
 
+type FileOffsetAndExpressionPair {

[Kevin Millikin (Google), 2017/05/11 10:38:35]

I'd just add at the top of the spec (maybe just before or after List):

// Untagged pairs.
type Pair<T0, T1> {
  T0 first;
  T1 second;
}

And below:

List<Pair<FileOffset, Expression>> expressions;

[jensj, 2017/05/11 12:59:24]

Done.

+  FileOffset offset;
+  Expression expression;
+}
+
 type SwitchCase {
   // Note: there is no tag on SwitchCase
-  List<Expression> expressions;
-  FileOffset[expressions.length] expressionOffsets; // 1-to-1 with expressions.
+  List<FileOffsetAndExpressionPair> expressions;
   Byte isDefault; // 1 if default, 0 is not default.
   Statement body;
 }
 
 type ContinueSwitchStatement extends Statement {
   Byte tag = 72;
 
   // Reference to the Nth SwitchCase in scope.
   //
   // A SwitchCase is in scope everywhere within its enclosing switch,
@@ skipping 15 matching lines @@
 
 type ReturnStatement extends Statement {
   Byte tag = 74;
   FileOffset fileOffset;
   Option<Expression> expression;
 }
 
 type TryCatch extends Statement {
   Byte tag = 75;
   Statement body;
+  Byte anyCatchNeedsStackTrace; // 1 if any catch needs a stacktrace (have a stacktrace variable).
   List<Catch> catches;
 }
 
 type Catch {
   DartType guard;
   Option<VariableDeclaration> exception;
   Option<VariableDeclaration> stackTrace;
   Statement body;
 }
 
@@ skipping 71 matching lines @@
 type SimpleInterfaceType extends DartType {
   Byte tag = 96; // Note: tag is out of order.
   ClassReference class;
   // Equivalent to InterfaceType with empty list of type arguments.
 }
 
 type FunctionType extends DartType {
   Byte tag = 94;
   List<TypeParameter> typeParameters;
   UInt requiredParameterCount;
+  UInt totalParameterCount; // positionalParameters.length + namedParameters.length
   List<DartType> positionalParameters;
   List<NamedDartType> namedParameters;
   DartType returnType;
 }
 
 type SimpleFunctionType extends DartType {
   Byte tag = 97; // Note: tag is out of order.
   List<DartType> positionalParameters;
   DartType returnType;
   // Equivalent to a FunctionType with no type parameters or named parameters,
@@ skipping 19 matching lines @@
   // from the definition of scoping, since type parameter N+1 is not "in scope"
   // in the bound of type parameter N, but it takes up an index as if it was in
   // scope there.
   //
   // The type parameter can be bound by a Class, FunctionNode, or FunctionType.
   //
   // Note that constructors currently do not declare type parameters.  Uses of
   // the class type parameters in a constructor refer to those declared on the
   // class.
   UInt index;
+
+  // Byte offset in the binary for the type declaration.
+  // Note: This can also be 0, which is a 'forward reference' and is not to be used.
+  UInt typeParameterPosition;
 }
 
 type VectorType extends DartType {
   Byte tag = 88;
 }
 
 type TypeParameter {
   // Note: there is no tag on TypeParameter
   StringReference name; // Cosmetic, may be empty, not unique.
   DartType bound; // 'dynamic' if no explicit bound was given.
 }
 
 ```