[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 28 matching lines @@
   Byte byte3(xxxxxxxx);
   Byte byte4(xxxxxxxx); // least significant byte
 }
 
 type MagicWord = big endian 32-bit unsigned integer
 
 type List<T> {
   UInt length;
   T[length] items;
 }
+
+// Untagged pairs.
+type Pair<T0, T1> {
+  T0 first;
+  T1 second;
+}
 ```
 
 A string table consists of an array of end offsets and a payload array of
 strings encoded as UTF-8.  The array of end offsets maps a string index to the
 offset of the _next_ string in the table or the offset of the end of the array
 for the last string.  These offsets are relative to the string payload array.
 Thus, string number 0 consists of the UTF-8 encoded string stretching from
 offset 0 (inclusive) to endOffset[0] (exclusive); and string number N for N > 0
 consists of the UTF-8 encoded string stretching from offset endOffset[N-1]
 (inclusive) to endOffset[N] (exclusive).
@@ skipping 280 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 333 matching lines @@
 }
 
 type SwitchStatement extends Statement {
   Byte tag = 71;
   Expression expression;
   List<SwitchCase> cases;
 }
 
 type SwitchCase {
   // Note: there is no tag on SwitchCase
-  List<Expression> expressions;
-  FileOffset[expressions.length] expressionOffsets; // 1-to-1 with expressions.
+  List<Pair<FileOffset, Expression>> 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;
   Option<DartType> bound;
 }
 
 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.
 }
 
 ```