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

runtime/vm/kernel_binary.cc

Index: runtime/vm/kernel_binary.cc
diff --git a/runtime/vm/kernel_binary.cc b/runtime/vm/kernel_binary.cc
index 8f63e6b05ee5ce69871239d7e100ee50294c587c..3af19156227ddbd92ed4d12b23a0b531dfe6f503 100644
--- a/runtime/vm/kernel_binary.cc
+++ b/runtime/vm/kernel_binary.cc
@@ -194,6 +194,10 @@ Library* Library::ReadFrom(Reader* reader) {
 
   fields().ReadFrom<Field>(reader, this);
   procedures().ReadFrom<Procedure>(reader, this);
+
+  cannot_stream_ = classes().cannot_stream() || fields().cannot_stream() ||
+                   procedures().cannot_stream();
+
   return this;
 }
 
@@ -224,6 +228,8 @@ Class* Class::ReadFrom(Reader* reader) {
   reader->record_token_position(position_);
   annotations_.ReadFromStatic<Expression>(reader);
 
+  cannot_stream_ = annotations_.cannot_stream();
+
   return this;
 }
 
@@ -244,6 +250,9 @@ NormalClass* NormalClass::ReadFrom(Reader* reader) {
   constructors_.ReadFrom<Constructor>(reader, this);
   procedures_.ReadFrom<Procedure>(reader, this);
 
+  cannot_stream_ = fields_.cannot_stream() || constructors_.cannot_stream() ||

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

This is overwriting cannot_stream_ which might have been set in Class::ReadFrom.
 Don't we want

cannot_stream_ = cannot_stream_ || ...

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

Done.

+                   procedures_.cannot_stream();
+
   return this;
 }
 
@@ -259,6 +268,9 @@ MixinClass* MixinClass::ReadFrom(Reader* reader) {
   implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
       reader);
   constructors_.ReadFrom<Constructor>(reader, this);
+
+  cannot_stream_ = constructors_.cannot_stream();
+
   return this;
 }
 
@@ -327,6 +339,10 @@ Field* Field::ReadFrom(Reader* reader) {
   annotations_.ReadFromStatic<Expression>(reader);
   type_ = DartType::ReadFrom(reader);
   initializer_ = reader->ReadOptional<Expression>();
+
+  cannot_stream_ = (initializer_ != NULL && initializer_->cannot_stream()) ||
+                   annotations_.cannot_stream();
+
   return this;
 }
 
@@ -345,6 +361,10 @@ Constructor* Constructor::ReadFrom(Reader* reader) {
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = FunctionNode::ReadFrom(reader);
   initializers_.ReadFromStatic<Initializer>(reader);
+
+  cannot_stream_ = annotations_.cannot_stream() || function_->cannot_stream() ||
+                   initializers_.cannot_stream();
+
   return this;
 }
 
@@ -367,6 +387,10 @@ Procedure* Procedure::ReadFrom(Reader* reader) {
   reader->record_token_position(end_position_);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = reader->ReadOptional<FunctionNode>();
+
+  cannot_stream_ = annotations_.cannot_stream() ||
+                   (function_ != NULL && function_->cannot_stream());
+
   return this;
 }
 
@@ -403,6 +427,9 @@ FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) {
   FieldInitializer* initializer = new FieldInitializer();
   initializer->field_reference_ = Reference::ReadMemberFrom(reader);
   initializer->value_ = Expression::ReadFrom(reader);
+
+  initializer->cannot_stream_ = initializer->value_->cannot_stream();
+
   return initializer;
 }
 
@@ -412,6 +439,9 @@ SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) {
   SuperInitializer* init = new SuperInitializer();
   init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
+
+  init->cannot_stream_ = init->arguments_->cannot_stream();
+
   return init;
 }
 
@@ -421,6 +451,9 @@ RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) {
   RedirectingInitializer* init = new RedirectingInitializer();
   init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
+
+  init->cannot_stream_ = init->arguments_->cannot_stream();
+
   return init;
 }
 
@@ -429,6 +462,9 @@ LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   LocalInitializer* init = new LocalInitializer();
   init->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
+
+  init->cannot_stream_ = init->variable_->cannot_stream();
+
   return init;
 }
 
@@ -557,7 +593,9 @@ VariableGet* VariableGet::ReadFrom(Reader* reader) {
   VariableGet* get = new VariableGet();
   get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
+  get->variable_kernel_offset_ = reader->ReadUInt();
   get->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
+  ASSERT(get->variable_->kernel_offset() == get->variable_kernel_offset_);
   reader->ReadOptional<DartType>();  // Unused promoted type.
   return get;
 }
@@ -568,7 +606,9 @@ VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) {
   VariableGet* get = new VariableGet();
   get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
+  get->variable_kernel_offset_ = reader->ReadUInt();
   get->variable_ = reader->helper()->variables().Lookup(payload);
+  ASSERT(get->variable_->kernel_offset() == get->variable_kernel_offset_);
   return get;
 }
 
@@ -578,8 +618,13 @@ VariableSet* VariableSet::ReadFrom(Reader* reader) {
   VariableSet* set = new VariableSet();
   set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
+  set->variable_kernel_offset_ = reader->ReadUInt();
   set->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
+  ASSERT(set->variable_->kernel_offset() == set->variable_kernel_offset_);
   set->expression_ = Expression::ReadFrom(reader);
+
+  set->cannot_stream_ = set->expression_->cannot_stream();
+
   return set;
 }
 
@@ -590,7 +635,12 @@ VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) {
   set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->variable_ = reader->helper()->variables().Lookup(payload);
   set->position_ = reader->ReadPosition();
+  set->variable_kernel_offset_ = reader->ReadUInt();
+  ASSERT(set->variable_->kernel_offset() == set->variable_kernel_offset_);
   set->expression_ = Expression::ReadFrom(reader);
+
+  set->cannot_stream_ = set->expression_->cannot_stream();
+
   return set;
 }
 
@@ -603,6 +653,9 @@ PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   get->receiver_ = Expression::ReadFrom(reader);
   get->name_ = Name::ReadFrom(reader);
   get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
+
+  get->cannot_stream_ = get->receiver_->cannot_stream();
+
   return get;
 }
 
@@ -616,6 +669,10 @@ PropertySet* PropertySet::ReadFrom(Reader* reader) {
   set->name_ = Name::ReadFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
+
+  set->cannot_stream_ =
+      set->receiver_->cannot_stream() || set->value_->cannot_stream();
+
   return set;
 }
 
@@ -627,6 +684,9 @@ DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->target_reference_ = Reference::ReadMemberFrom(reader);
+
+  get->cannot_stream_ = get->receiver_->cannot_stream();
+
   return get;
 }
 
@@ -639,6 +699,10 @@ DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
   set->receiver_ = Expression::ReadFrom(reader);
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
+
+  set->cannot_stream_ =
+      set->receiver_->cannot_stream() || set->value_->cannot_stream();
+
   return set;
 }
 
@@ -660,6 +724,9 @@ StaticSet* StaticSet::ReadFrom(Reader* reader) {
   set->position_ = reader->ReadPosition();
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->expression_ = Expression::ReadFrom(reader);
+
+  set->cannot_stream_ = set->expression_->cannot_stream();
+
   return set;
 }
 
@@ -667,9 +734,15 @@ StaticSet* StaticSet::ReadFrom(Reader* reader) {
 Arguments* Arguments::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Arguments* arguments = new Arguments();
+  intptr_t num_arguments = reader->ReadUInt();
   arguments->types().ReadFromStatic<DartType>(reader);
   arguments->positional().ReadFromStatic<Expression>(reader);
   arguments->named().ReadFromStatic<NamedExpression>(reader);
+  ASSERT(arguments->count() == num_arguments);
+
+  arguments->cannot_stream_ = arguments->positional().cannot_stream() ||
+                              arguments->named().cannot_stream();
+
   return arguments;
 }
 
@@ -678,7 +751,11 @@ NamedExpression* NamedExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   intptr_t name_index = reader->ReadUInt();
   Expression* expression = Expression::ReadFrom(reader);
-  return new NamedExpression(name_index, expression);
+  NamedExpression* named = new NamedExpression(name_index, expression);
+
+  named->cannot_stream_ = expression->cannot_stream();
+
+  return named;
 }
 
 
@@ -692,6 +769,10 @@ MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
   invocation->arguments_ = Arguments::ReadFrom(reader);
   invocation->interface_target_reference_ =
       Reference::ReadMemberFrom(reader, true);
+
+  invocation->cannot_stream_ = invocation->receiver_->cannot_stream() ||
+                               invocation->arguments_->cannot_stream();
+
   return invocation;
 }
 
@@ -703,6 +784,10 @@ DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->cannot_stream_ = invocation->receiver_->cannot_stream() ||
+                               invocation->arguments_->cannot_stream();
+
   return invocation;
 }
 
@@ -715,6 +800,9 @@ StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
   invocation->position_ = reader->ReadPosition();
   invocation->procedure_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->cannot_stream_ = invocation->arguments_->cannot_stream();
+
   return invocation;
 }
 
@@ -728,6 +816,9 @@ ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
   invocation->position_ = reader->ReadPosition();
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->cannot_stream_ = invocation->arguments_->cannot_stream();
+
   return invocation;
 }
 
@@ -737,6 +828,9 @@ Not* Not::ReadFrom(Reader* reader) {
   Not* n = new Not();
   n->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   n->expression_ = Expression::ReadFrom(reader);
+
+  n->cannot_stream_ = n->expression_->cannot_stream();
+
   return n;
 }
 
@@ -748,6 +842,10 @@ LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) {
   expr->left_ = Expression::ReadFrom(reader);
   expr->operator_ = static_cast<Operator>(reader->ReadByte());
   expr->right_ = Expression::ReadFrom(reader);
+
+  expr->cannot_stream_ =
+      expr->left_->cannot_stream() || expr->right_->cannot_stream();
+
   return expr;
 }
 
@@ -760,6 +858,11 @@ ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) {
   expr->then_ = Expression::ReadFrom(reader);
   expr->otherwise_ = Expression::ReadFrom(reader);
   reader->ReadOptional<DartType>();  // Unused static type.
+
+  expr->cannot_stream_ = expr->condition_->cannot_stream() ||
+                         expr->then_->cannot_stream() ||
+                         expr->otherwise_->cannot_stream();
+
   return expr;
 }
 
@@ -770,6 +873,9 @@ StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
   concat->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   concat->position_ = reader->ReadPosition();
   concat->expressions_.ReadFromStatic<Expression>(reader);
+
+  concat->cannot_stream_ = concat->expressions_.cannot_stream();
+
   return concat;
 }
 
@@ -781,6 +887,9 @@ IsExpression* IsExpression::ReadFrom(Reader* reader) {
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
+
+  expr->cannot_stream_ = expr->operand_->cannot_stream();
+
   return expr;
 }
 
@@ -792,6 +901,9 @@ AsExpression* AsExpression::ReadFrom(Reader* reader) {
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
+
+  expr->cannot_stream_ = expr->operand_->cannot_stream();
+
   return expr;
 }
 
@@ -900,6 +1012,9 @@ Throw* Throw::ReadFrom(Reader* reader) {
   t->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   t->position_ = reader->ReadPosition();
   t->expression_ = Expression::ReadFrom(reader);
+
+  t->cannot_stream_ = t->expression_->cannot_stream();
+
   return t;
 }
 
@@ -912,6 +1027,9 @@ ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
   literal->position_ = reader->ReadPosition();
   literal->type_ = DartType::ReadFrom(reader);
   literal->expressions_.ReadFromStatic<Expression>(reader);
+
+  literal->cannot_stream_ = literal->expressions_.cannot_stream();
+
   return literal;
 }
 
@@ -925,6 +1043,9 @@ MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
   literal->key_type_ = DartType::ReadFrom(reader);
   literal->value_type_ = DartType::ReadFrom(reader);
   literal->entries_.ReadFromStatic<MapEntry>(reader);
+
+  literal->cannot_stream_ = literal->entries_.cannot_stream();
+
   return literal;
 }
 
@@ -933,6 +1054,10 @@ MapEntry* MapEntry::ReadFrom(Reader* reader) {
   MapEntry* entry = new MapEntry();
   entry->key_ = Expression::ReadFrom(reader);
   entry->value_ = Expression::ReadFrom(reader);
+
+  entry->cannot_stream_ =
+      entry->key_->cannot_stream() || entry->value_->cannot_stream();
+
   return entry;
 }
 
@@ -942,6 +1067,9 @@ AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) {
   AwaitExpression* await = new AwaitExpression();
   await->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   await->operand_ = Expression::ReadFrom(reader);
+
+  await->cannot_stream_ = await->operand_->cannot_stream();
+
   return await;
 }
 
@@ -952,6 +1080,9 @@ FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
   FunctionExpression* expr = new FunctionExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->function_ = FunctionNode::ReadFrom(reader);
+
+  expr->cannot_stream_ = true;
+
   return expr;
 }
 
@@ -968,6 +1099,9 @@ Let* Let::ReadFrom(Reader* reader) {
   let->position_ = reader->min_position();
   let->end_position_ = reader->max_position();
 
+  let->cannot_stream_ =
+      let->variable_->cannot_stream() || let->body_->cannot_stream();
+
   return let;
 }
 
@@ -992,6 +1126,8 @@ VectorGet* VectorGet::ReadFrom(Reader* reader) {
   vector_get->vector_expression_ = Expression::ReadFrom(reader);
   vector_get->index_ = reader->ReadUInt();
 
+  vector_get->cannot_stream_ = vector_get->vector_expression_->cannot_stream();
+
   return vector_get;
 }
 
@@ -1005,6 +1141,10 @@ VectorSet* VectorSet::ReadFrom(Reader* reader) {
   vector_set->index_ = reader->ReadUInt();
   vector_set->value_ = Expression::ReadFrom(reader);
 
+  vector_set->cannot_stream_ =
+      vector_set->vector_expression_->cannot_stream() ||
+      vector_set->value_->cannot_stream();
+
   return vector_set;
 }
 
@@ -1017,6 +1157,9 @@ VectorCopy* VectorCopy::ReadFrom(Reader* reader) {
       reader->offset() - 1;  // -1 to include tag byte.
   vector_copy->vector_expression_ = Expression::ReadFrom(reader);
 
+  vector_copy->cannot_stream_ =
+      vector_copy->vector_expression_->cannot_stream();
+
   return vector_copy;
 }
 
@@ -1033,6 +1176,9 @@ ClosureCreation* ClosureCreation::ReadFrom(Reader* reader) {
   closure_creation->function_type_ =
       FunctionType::Cast(DartType::ReadFrom(reader));
 
+  closure_creation->cannot_stream_ =
+      closure_creation->context_vector_->cannot_stream();
+
   return closure_creation;
 }
 
@@ -1092,13 +1238,22 @@ Statement* Statement::ReadFrom(Reader* reader) {
 
 InvalidStatement* InvalidStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  return new InvalidStatement();
+  InvalidStatement* stmt = new InvalidStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  return stmt;
 }
 
 
 ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  return new ExpressionStatement(Expression::ReadFrom(reader));
+  intptr_t offset = reader->offset() - 1;  // -1 to include tag byte.
+  ExpressionStatement* stmt =
+      new ExpressionStatement(Expression::ReadFrom(reader));
+  stmt->kernel_offset_ = offset;
+
+  stmt->cannot_stream_ = stmt->expression_->cannot_stream();
+
+  return stmt;
 }
 
 
@@ -1113,21 +1268,31 @@ Block* Block::ReadFromImpl(Reader* reader) {
   block->position_ = reader->min_position();
   block->end_position_ = reader->max_position();
 
+  block->cannot_stream_ = block->statements().cannot_stream();
+
   return block;
 }
 
 
 EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  return new EmptyStatement();
+  EmptyStatement* stmt = new EmptyStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  return stmt;
 }
 
 
 AssertStatement* AssertStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AssertStatement* stmt = new AssertStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   stmt->condition_ = Expression::ReadFrom(reader);
   stmt->message_ = reader->ReadOptional<Expression>();
+
+  stmt->cannot_stream_ =
+      stmt->condition_->cannot_stream() ||
+      (stmt->message_ != NULL && stmt->message_->cannot_stream());
+
   return stmt;
 }
 
@@ -1135,9 +1300,14 @@ AssertStatement* AssertStatement::ReadFrom(Reader* reader) {
 LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   LabeledStatement* stmt = new LabeledStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+
   reader->helper()->labels()->Push(stmt);
   stmt->body_ = Statement::ReadFrom(reader);
   reader->helper()->labels()->Pop(stmt);
+
+  stmt->cannot_stream_ = stmt->body_->cannot_stream();
+
   return stmt;
 }
 
@@ -1145,8 +1315,9 @@ LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) {
 BreakStatement* BreakStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   BreakStatement* stmt = new BreakStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   stmt->position_ = reader->ReadPosition();
-  stmt->target_ = reader->helper()->labels()->Lookup(reader->ReadUInt());
+  stmt->target_index_ = reader->ReadUInt();
   return stmt;
 }
 
@@ -1154,8 +1325,13 @@ BreakStatement* BreakStatement::ReadFrom(Reader* reader) {
 WhileStatement* WhileStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   WhileStatement* stmt = new WhileStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   stmt->condition_ = Expression::ReadFrom(reader);
   stmt->body_ = Statement::ReadFrom(reader);
+
+  stmt->cannot_stream_ =
+      stmt->condition_->cannot_stream() || stmt->body_->cannot_stream();
+
   return stmt;
 }
 
@@ -1163,8 +1339,13 @@ WhileStatement* WhileStatement::ReadFrom(Reader* reader) {
 DoStatement* DoStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DoStatement* dostmt = new DoStatement();
+  dostmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   dostmt->body_ = Statement::ReadFrom(reader);
   dostmt->condition_ = Expression::ReadFrom(reader);
+
+  dostmt->cannot_stream_ =
+      dostmt->body_->cannot_stream() || dostmt->condition_->cannot_stream();
+
   return dostmt;
 }
 
@@ -1183,6 +1364,11 @@ ForStatement* ForStatement::ReadFrom(Reader* reader) {
   forstmt->end_position_ = reader->max_position();
   forstmt->position_ = reader->min_position();
 
+  forstmt->cannot_stream_ =
+      forstmt->body_->cannot_stream() ||
+      (forstmt->condition_ != NULL && forstmt->condition_->cannot_stream()) ||
+      forstmt->variables_.cannot_stream() || forstmt->updates_.cannot_stream();
+
   return forstmt;
 }
 
@@ -1205,39 +1391,49 @@ ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
   }
   forinstmt->variable_->set_end_position(forinstmt->position_);
 
+  forinstmt->cannot_stream_ = forinstmt->variable_->cannot_stream() ||
+                              forinstmt->iterable_->cannot_stream() ||
+                              forinstmt->body_->cannot_stream();
+
   return forinstmt;
 }
 
 
 SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  SwitchCaseScope<ReaderHelper> scope(reader->helper());
   SwitchStatement* stmt = new SwitchStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   stmt->condition_ = Expression::ReadFrom(reader);
-  // We need to explicitly create empty [SwitchCase]s first in order to add them
-  // to the [SwitchCaseScope]. This is necessary since a [Statement] in a switch
-  // case can refer to one defined later on.
   int count = reader->ReadUInt();
+  stmt->cases_.EnsureInitialized(count);
   for (intptr_t i = 0; i < count; i++) {
     SwitchCase* sc = stmt->cases_.GetOrCreate<SwitchCase>(i);
-    reader->helper()->switch_cases().Push(sc);
-  }
-  for (intptr_t i = 0; i < count; i++) {
-    SwitchCase* sc = stmt->cases_[i];
     sc->ReadFrom(reader);
   }
+
+  stmt->cannot_stream_ =
+      stmt->condition_->cannot_stream() || stmt->cases_.cannot_stream();
+
   return stmt;
 }
 
 
 SwitchCase* SwitchCase::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  expressions_.ReadFromStatic<Expression>(reader);
-  for (intptr_t i = 0; i < expressions_.length(); ++i) {
-    expressions_[i]->set_position(reader->ReadPosition());
+  int length = reader->ReadListLength();
+  expressions_.EnsureInitialized(length);
+
+  for (intptr_t i = 0; i < length; i++) {
+    ASSERT(expressions_[i] == NULL);
+    TokenPosition position = reader->ReadPosition();
+    expressions_[i] = Expression::ReadFrom(reader);
+    expressions_[i]->set_position(position);
   }
   is_default_ = reader->ReadBool();
   body_ = Statement::ReadFrom(reader);
+
+  cannot_stream_ = expressions_.cannot_stream() || body_->cannot_stream();
+
   return this;
 }
 
@@ -1245,7 +1441,9 @@ SwitchCase* SwitchCase::ReadFrom(Reader* reader) {
 ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ContinueSwitchStatement* stmt = new ContinueSwitchStatement();
-  stmt->target_ = reader->helper()->switch_cases().Lookup(reader->ReadUInt());
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  stmt->target_index_ = reader->ReadUInt();
+
   return stmt;
 }
 
@@ -1253,9 +1451,15 @@ ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) {
 IfStatement* IfStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   IfStatement* ifstmt = new IfStatement();
+  ifstmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   ifstmt->condition_ = Expression::ReadFrom(reader);
   ifstmt->then_ = Statement::ReadFrom(reader);
   ifstmt->otherwise_ = Statement::ReadFrom(reader);
+
+  ifstmt->cannot_stream_ = ifstmt->condition_->cannot_stream() ||
+                           ifstmt->then_->cannot_stream() ||
+                           ifstmt->otherwise_->cannot_stream();
+
   return ifstmt;
 }
 
@@ -1263,8 +1467,13 @@ IfStatement* IfStatement::ReadFrom(Reader* reader) {
 ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ReturnStatement* ret = new ReturnStatement();
+  ret->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   ret->position_ = reader->ReadPosition();
   ret->expression_ = reader->ReadOptional<Expression>();
+
+  ret->cannot_stream_ =
+      (ret->expression_ != NULL && ret->expression_->cannot_stream());
+
   return ret;
 }
 
@@ -1274,10 +1483,15 @@ TryCatch* TryCatch::ReadFrom(Reader* reader) {
   PositionScope scope(reader);
 
   TryCatch* tc = new TryCatch();
+  tc->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   tc->body_ = Statement::ReadFrom(reader);
+  reader->ReadBool();  // whether any catch needs a stacktrace.
   tc->catches_.ReadFromStatic<Catch>(reader);
   tc->position_ = reader->min_position();
 
+  tc->cannot_stream_ =
+      tc->body_->cannot_stream() || tc->catches_.cannot_stream();
+
   return tc;
 }
 
@@ -1298,6 +1512,8 @@ Catch* Catch::ReadFrom(Reader* reader) {
   c->end_position_ = reader->max_position();
   c->position_ = reader->min_position();
 
+  c->cannot_stream_ = c->body_->cannot_stream();
+
   return c;
 }
 
@@ -1305,8 +1521,13 @@ Catch* Catch::ReadFrom(Reader* reader) {
 TryFinally* TryFinally::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TryFinally* tf = new TryFinally();
+  tf->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   tf->body_ = Statement::ReadFrom(reader);
   tf->finalizer_ = Statement::ReadFrom(reader);
+
+  tf->cannot_stream_ =
+      tf->body_->cannot_stream() || tf->finalizer_->cannot_stream();
+
   return tf;
 }
 
@@ -1314,10 +1535,14 @@ TryFinally* TryFinally::ReadFrom(Reader* reader) {
 YieldStatement* YieldStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   YieldStatement* stmt = new YieldStatement();
+  stmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   stmt->position_ = reader->ReadPosition();
   reader->record_yield_token_position(stmt->position_);
   stmt->flags_ = reader->ReadByte();
   stmt->expression_ = Expression::ReadFrom(reader);
+
+  stmt->cannot_stream_ = stmt->expression_->cannot_stream();
+
   return stmt;
 }
 
@@ -1352,6 +1577,9 @@ VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader,
   decl->end_position_ = position;
   reader->helper()->variables().Push(decl);
 
+  decl->cannot_stream_ =
+      decl->initializer_ != NULL && decl->initializer_->cannot_stream();
+
   return decl;
 }
 
@@ -1364,6 +1592,10 @@ FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
+
+  decl->cannot_stream_ = decl->variable_->cannot_stream() ||
+                         decl->function_->cannot_stream() || true;
+
   return decl;
 }
 
@@ -1464,8 +1696,12 @@ FunctionType* FunctionType::ReadFrom(Reader* reader) {
   TypeParameterScope<ReaderHelper> scope(reader->helper());
   type->type_parameters().ReadFrom(reader);
   type->required_parameter_count_ = reader->ReadUInt();
+  intptr_t total_parameter_count = reader->ReadUInt();
   type->positional_parameters().ReadFromStatic<DartType>(reader);
   type->named_parameters().ReadFromStatic<NamedParameter>(reader);
+  ASSERT(type->positional_parameters().length() +
+             type->named_parameters().length() ==
+         total_parameter_count);
   type->return_type_ = DartType::ReadFrom(reader);
   return type;
 }
@@ -1487,6 +1723,7 @@ TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) {
   TypeParameterType* type = new TypeParameterType();
   type->parameter_ =
       reader->helper()->type_parameters().Lookup(reader->ReadUInt());
+  reader->ReadUInt();  // binary offset of parameter
   return type;
 }
 
@@ -1550,6 +1787,8 @@ Program* Program::ReadFrom(Reader* reader) {
   program->main_method_reference_ =
       Reference::ReadMemberFrom(reader, /*allow_null=*/true);
 
+  program->cannot_stream_ = true;
+
   return program;
 }
 
@@ -1577,12 +1816,19 @@ FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
       reader->helper());
   VariableScope<ReaderHelper> vars(reader->helper());
   function->body_ = reader->ReadOptional<Statement>();
+
+  function->cannot_stream_ =
+      function->positional_parameters_.cannot_stream() ||
+      function->named_parameters_.cannot_stream() ||
+      (function->body_ != NULL && function->body_->cannot_stream());
+
   return function;
 }
 
 
 TypeParameter* TypeParameter::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
+  kernel_offset_ = reader->offset();
   name_index_ = reader->ReadUInt();
   bound_ = DartType::ReadFrom(reader);
   return this;