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

runtime/vm/kernel_binary.cc

 // 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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/kernel_binary.h"
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
@@ skipping 183 matching lines @@
   classes().EnsureInitialized(num_classes);
   for (intptr_t i = 0; i < num_classes; i++) {
     Tag tag = reader->ReadTag();
     ASSERT(tag == kClass);
     NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
     klass->ReadFrom(reader);
   }
 
   fields().ReadFrom<Field>(reader, this);
   procedures().ReadFrom<Procedure>(reader, this);
+
+  can_stream_ =
+      classes().CanStream() && fields().CanStream() && procedures().CanStream();
+
   return this;
 }
 
 
 Typedef* Typedef::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   canonical_name_ = reader->ReadCanonicalNameReference();
   position_ = reader->ReadPosition(false);
   name_index_ = StringIndex(reader->ReadUInt());
@@ skipping 10 matching lines @@
 
   canonical_name_ = reader->ReadCanonicalNameReference();
   position_ = reader->ReadPosition(false);
   is_abstract_ = reader->ReadBool();
   name_index_ = StringIndex(reader->ReadUInt());
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   annotations_.ReadFromStatic<Expression>(reader);
 
+  can_stream_ = annotations_.CanStream();
+
   return this;
 }
 
 
 NormalClass* NormalClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Class::ReadFrom(reader);
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   type_parameters_.ReadFrom(reader);
   DartType* type = reader->ReadOptional<DartType>();
 
   super_class_ = InterfaceType::Cast(type);
   reader->ReadOptional<DartType>();  // Mixed-in type is unused.
   implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
       reader);
   fields_.ReadFrom<Field>(reader, this);
   constructors_.ReadFrom<Constructor>(reader, this);
   procedures_.ReadFrom<Procedure>(reader, this);
 
+  can_stream_ = can_stream_ && fields_.CanStream() &&
+                constructors_.CanStream() && procedures_.CanStream();
+
   return this;
 }
 
 
 MixinClass* MixinClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   Class::ReadFrom(reader);
   type_parameters_.ReadFrom(reader);
   first_ = InterfaceType::Cast(DartType::ReadFrom(reader));
   second_ = InterfaceType::Cast(DartType::ReadFrom(reader));
   implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
       reader);
   constructors_.ReadFrom<Constructor>(reader, this);
+
+  can_stream_ = constructors_.CanStream();
+
   return this;
 }
 
 
 NameIndex Reference::ReadMemberFrom(Reader* reader, bool allow_null) {
   TRACE_READ_OFFSET();
   NameIndex canonical_name = reader->ReadCanonicalNameReference();
   if ((canonical_name == -1) && !allow_null) {
     FATAL("Expected a valid member reference, but got `null`");
   }
@@ skipping 32 matching lines @@
   end_position_ = reader->ReadPosition(false);
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   reader->record_token_position(end_position_);
   annotations_.ReadFromStatic<Expression>(reader);
   type_ = DartType::ReadFrom(reader);
   initializer_ = reader->ReadOptional<Expression>();
+
+  can_stream_ = (initializer_ == NULL || initializer_->can_stream()) &&
+                annotations_.CanStream();
+
   return this;
 }
 
 
 Constructor* Constructor::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kConstructor);
 
   canonical_name_ = reader->ReadCanonicalNameReference();
   VariableScope<ReaderHelper> parameters(reader->helper());
   position_ = reader->ReadPosition();
   end_position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = FunctionNode::ReadFrom(reader);
   initializers_.ReadFromStatic<Initializer>(reader);
+
+  can_stream_ = annotations_.CanStream() && function_->can_stream() &&
+                initializers_.CanStream();
+
   return this;
 }
 
 
 Procedure* Procedure::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kProcedure);
 
   canonical_name_ = reader->ReadCanonicalNameReference();
   VariableScope<ReaderHelper> parameters(reader->helper());
   position_ = reader->ReadPosition(false);
   end_position_ = reader->ReadPosition(false);
   kind_ = static_cast<ProcedureKind>(reader->ReadByte());
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
   reader->record_token_position(end_position_);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = reader->ReadOptional<FunctionNode>();
+
+  can_stream_ = annotations_.CanStream() &&
+                (function_ == NULL || function_->can_stream());
+
   return this;
 }
 
 
 Initializer* Initializer::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
     case kInvalidInitializer:
       return InvalidInitializer::ReadFromImpl(reader);
@@ skipping 16 matching lines @@
   TRACE_READ_OFFSET();
   return new InvalidInitializer();
 }
 
 
 FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   FieldInitializer* initializer = new FieldInitializer();
   initializer->field_reference_ = Reference::ReadMemberFrom(reader);
   initializer->value_ = Expression::ReadFrom(reader);
+
+  initializer->can_stream_ = initializer->value_->can_stream();
+
   return initializer;
 }
 
 
 SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   SuperInitializer* init = new SuperInitializer();
   init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
+
+  init->can_stream_ = init->arguments_->can_stream();
+
   return init;
 }
 
 
 RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   RedirectingInitializer* init = new RedirectingInitializer();
   init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
+
+  init->can_stream_ = init->arguments_->can_stream();
+
   return init;
 }
 
 
 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   LocalInitializer* init = new LocalInitializer();
   init->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
+
+  init->can_stream_ = init->variable_->can_stream();
+
   return init;
 }
 
 
 Expression* Expression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint8_t payload = 0;
   Tag tag = reader->ReadTag(&payload);
   switch (tag) {
     case kInvalidExpression:
@@ skipping 108 matching lines @@
       reader->offset() - 1;  // -1 to include tag byte.
   return invalid_expression;
 }
 
 
 VariableGet* VariableGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   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;
 }
 
 
 VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) {
   TRACE_READ_OFFSET();
   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;
 }
 
 
 VariableSet* VariableSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   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->can_stream_ = set->expression_->can_stream();
+
   return set;
 }
 
 
 VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) {
   TRACE_READ_OFFSET();
   VariableSet* set = new VariableSet();
   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->can_stream_ = set->expression_->can_stream();
+
   return set;
 }
 
 
 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertyGet* get = new PropertyGet();
   get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->name_ = Name::ReadFrom(reader);
   get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
+
+  get->can_stream_ = get->receiver_->can_stream();
+
   return get;
 }
 
 
 PropertySet* PropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertySet* set = new PropertySet();
   set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->name_ = Name::ReadFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
+
+  set->can_stream_ = set->receiver_->can_stream() && set->value_->can_stream();
+
   return set;
 }
 
 
 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertyGet* get = new DirectPropertyGet();
   get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->target_reference_ = Reference::ReadMemberFrom(reader);
+
+  get->can_stream_ = get->receiver_->can_stream();
+
   return get;
 }
 
 
 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertySet* set = new DirectPropertySet();
   set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
+
+  set->can_stream_ = set->receiver_->can_stream() && set->value_->can_stream();
+
   return set;
 }
 
 
 StaticGet* StaticGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticGet* get = new StaticGet();
   get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->target_reference_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 StaticSet* StaticSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticSet* set = new StaticSet();
   set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->expression_ = Expression::ReadFrom(reader);
+
+  set->can_stream_ = set->expression_->can_stream();
+
   return set;
 }
 
 
 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->can_stream_ =
+      arguments->positional().CanStream() && arguments->named().CanStream();
+
   return arguments;
 }
 
 
 NamedExpression* NamedExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StringIndex name_index(reader->ReadUInt());
   Expression* expression = Expression::ReadFrom(reader);
-  return new NamedExpression(name_index, expression);
+  NamedExpression* named = new NamedExpression(name_index, expression);
+
+  named->can_stream_ = expression->can_stream();
+
+  return named;
 }
 
 
 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   MethodInvocation* invocation = new MethodInvocation();
   invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->position_ = reader->ReadPosition();
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->name_ = Name::ReadFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   invocation->interface_target_reference_ =
       Reference::ReadMemberFrom(reader, true);
+
+  invocation->can_stream_ = invocation->receiver_->can_stream() &&
+                            invocation->arguments_->can_stream();
+
   return invocation;
 }
 
 
 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectMethodInvocation* invocation = new DirectMethodInvocation();
   invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->can_stream_ = invocation->receiver_->can_stream() &&
+                            invocation->arguments_->can_stream();
+
   return invocation;
 }
 
 
 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   StaticInvocation* invocation = new StaticInvocation();
   invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
   invocation->procedure_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->can_stream_ = invocation->arguments_->can_stream();
+
   return invocation;
 }
 
 
 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
                                                        bool is_const) {
   TRACE_READ_OFFSET();
   ConstructorInvocation* invocation = new ConstructorInvocation();
   invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
+
+  invocation->can_stream_ = invocation->arguments_->can_stream();
+
   return invocation;
 }
 
 
 Not* Not::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Not* n = new Not();
   n->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   n->expression_ = Expression::ReadFrom(reader);
+
+  n->can_stream_ = n->expression_->can_stream();
+
   return n;
 }
 
 
 LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   LogicalExpression* expr = new LogicalExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->left_ = Expression::ReadFrom(reader);
   expr->operator_ = static_cast<Operator>(reader->ReadByte());
   expr->right_ = Expression::ReadFrom(reader);
+
+  expr->can_stream_ = expr->left_->can_stream() && expr->right_->can_stream();
+
   return expr;
 }
 
 
 ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ConditionalExpression* expr = new ConditionalExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->condition_ = Expression::ReadFrom(reader);
   expr->then_ = Expression::ReadFrom(reader);
   expr->otherwise_ = Expression::ReadFrom(reader);
   reader->ReadOptional<DartType>();  // Unused static type.
+
+  expr->can_stream_ = expr->condition_->can_stream() &&
+                      expr->then_->can_stream() &&
+                      expr->otherwise_->can_stream();
+
   return expr;
 }
 
 
 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StringConcatenation* concat = new StringConcatenation();
   concat->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   concat->position_ = reader->ReadPosition();
   concat->expressions_.ReadFromStatic<Expression>(reader);
+
+  concat->can_stream_ = concat->expressions_.CanStream();
+
   return concat;
 }
 
 
 IsExpression* IsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   IsExpression* expr = new IsExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
+
+  expr->can_stream_ = expr->operand_->can_stream();
+
   return expr;
 }
 
 
 AsExpression* AsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AsExpression* expr = new AsExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
+
+  expr->can_stream_ = expr->operand_->can_stream();
+
   return expr;
 }
 
 
 StringLiteral* StringLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   intptr_t offset = reader->offset() - 1;  // -1 to include tag byte.
   StringLiteral* lit = new StringLiteral(StringIndex(reader->ReadUInt()));
   lit->kernel_offset_ = offset;
   return lit;
@@ skipping 88 matching lines @@
   return rethrow;
 }
 
 
 Throw* Throw::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Throw* t = new Throw();
   t->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   t->position_ = reader->ReadPosition();
   t->expression_ = Expression::ReadFrom(reader);
+
+  t->can_stream_ = t->expression_->can_stream();
+
   return t;
 }
 
 
 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   ListLiteral* literal = new ListLiteral();
   literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->is_const_ = is_const;
   literal->position_ = reader->ReadPosition();
   literal->type_ = DartType::ReadFrom(reader);
   literal->expressions_.ReadFromStatic<Expression>(reader);
+
+  literal->can_stream_ = literal->expressions_.CanStream();
+
   return literal;
 }
 
 
 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   MapLiteral* literal = new MapLiteral();
   literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->is_const_ = is_const;
   literal->position_ = reader->ReadPosition();
   literal->key_type_ = DartType::ReadFrom(reader);
   literal->value_type_ = DartType::ReadFrom(reader);
   literal->entries_.ReadFromStatic<MapEntry>(reader);
+
+  literal->can_stream_ = literal->entries_.CanStream();
+
   return literal;
 }
 
 
 MapEntry* MapEntry::ReadFrom(Reader* reader) {
   MapEntry* entry = new MapEntry();
   entry->key_ = Expression::ReadFrom(reader);
   entry->value_ = Expression::ReadFrom(reader);
+
+  entry->can_stream_ = entry->key_->can_stream() && entry->value_->can_stream();
+
   return entry;
 }
 
 
 AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AwaitExpression* await = new AwaitExpression();
   await->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   await->operand_ = Expression::ReadFrom(reader);
+
+  await->can_stream_ = await->operand_->can_stream();
+
   return await;
 }
 
 
 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> parameters(reader->helper());
   FunctionExpression* expr = new FunctionExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->function_ = FunctionNode::ReadFrom(reader);
+
+  expr->can_stream_ = false;
+
   return expr;
 }
 
 
 Let* Let::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   Let* let = new Let();
   let->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   let->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   let->body_ = Expression::ReadFrom(reader);
   let->position_ = reader->min_position();
   let->end_position_ = reader->max_position();
 
+  let->can_stream_ = let->variable_->can_stream() && let->body_->can_stream();
+
   return let;
 }
 
 
 VectorCreation* VectorCreation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   VectorCreation* vector_creation = new VectorCreation();
   vector_creation->kernel_offset_ =
       reader->offset() - 1;  // -1 to include tag byte.
   vector_creation->value_ = reader->ReadUInt();
 
   return vector_creation;
 }
 
 
 VectorGet* VectorGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   VectorGet* vector_get = new VectorGet();
   vector_get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   vector_get->vector_expression_ = Expression::ReadFrom(reader);
   vector_get->index_ = reader->ReadUInt();
 
+  vector_get->can_stream_ = false;
+
   return vector_get;
 }
 
 
 VectorSet* VectorSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   VectorSet* vector_set = new VectorSet();
   vector_set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   vector_set->vector_expression_ = Expression::ReadFrom(reader);
   vector_set->index_ = reader->ReadUInt();
   vector_set->value_ = Expression::ReadFrom(reader);
 
+  vector_set->can_stream_ = false;
+
   return vector_set;
 }
 
 
 VectorCopy* VectorCopy::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   VectorCopy* vector_copy = new VectorCopy();
   vector_copy->kernel_offset_ =
       reader->offset() - 1;  // -1 to include tag byte.
   vector_copy->vector_expression_ = Expression::ReadFrom(reader);
 
+  vector_copy->can_stream_ = false;
+
   return vector_copy;
 }
 
 
 ClosureCreation* ClosureCreation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   ClosureCreation* closure_creation = new ClosureCreation();
   closure_creation->kernel_offset_ =
       reader->offset() - 1;  // to include tag byte.
   closure_creation->top_level_function_reference_ =
       Reference::ReadMemberFrom(reader);
   closure_creation->context_vector_ = Expression::ReadFrom(reader);
   closure_creation->function_type_ =
       FunctionType::Cast(DartType::ReadFrom(reader));
 
+  closure_creation->can_stream_ = false;
+
   return closure_creation;
 }
 
 
 Statement* Statement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
     case kInvalidStatement:
       return InvalidStatement::ReadFrom(reader);
@@ skipping 39 matching lines @@
       return FunctionDeclaration::ReadFrom(reader);
     default:
       UNREACHABLE();
   }
   return NULL;
 }
 
 
 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->can_stream_ = stmt->expression_->can_stream();
+
+  return stmt;
 }
 
 
 Block* Block::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   PositionScope scope(reader);
 
   VariableScope<ReaderHelper> vars(reader->helper());
   Block* block = new Block();
   block->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   block->statements().ReadFromStatic<Statement>(reader);
   block->position_ = reader->min_position();
   block->end_position_ = reader->max_position();
 
+  block->can_stream_ = block->statements().CanStream();
+
   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->can_stream_ = stmt->condition_->can_stream() &&
+                      (stmt->message_ == NULL || stmt->message_->can_stream());
+
   return stmt;
 }
 
 
 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->can_stream_ = stmt->body_->can_stream();
+
   return stmt;
 }
 
 
 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;
 }
 
 
 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->can_stream_ =
+      stmt->condition_->can_stream() && stmt->body_->can_stream();
+
   return stmt;
 }
 
 
 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->can_stream_ =
+      dostmt->body_->can_stream() && dostmt->condition_->can_stream();
+
   return dostmt;
 }
 
 
 ForStatement* ForStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   ForStatement* forstmt = new ForStatement();
   forstmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader);
   forstmt->condition_ = reader->ReadOptional<Expression>();
   forstmt->updates_.ReadFromStatic<Expression>(reader);
   forstmt->body_ = Statement::ReadFrom(reader);
   forstmt->end_position_ = reader->max_position();
   forstmt->position_ = reader->min_position();
 
+  forstmt->can_stream_ =
+      forstmt->body_->can_stream() &&
+      (forstmt->condition_ == NULL || forstmt->condition_->can_stream()) &&
+      forstmt->variables_.CanStream() && forstmt->updates_.CanStream();
+
   return forstmt;
 }
 
 
 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   ForInStatement* forinstmt = new ForInStatement();
   forinstmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   forinstmt->is_async_ = is_async;
   forinstmt->position_ = reader->ReadPosition();
   forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   forinstmt->iterable_ = Expression::ReadFrom(reader);
   forinstmt->body_ = Statement::ReadFrom(reader);
   forinstmt->end_position_ = reader->max_position();
   if (!forinstmt->position_.IsReal()) {
     forinstmt->position_ = reader->min_position();
   }
   forinstmt->variable_->set_end_position(forinstmt->position_);
 
+  forinstmt->can_stream_ = forinstmt->variable_->can_stream() &&
+                           forinstmt->iterable_->can_stream() &&
+                           forinstmt->body_->can_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->can_stream_ =
+      stmt->condition_->can_stream() && stmt->cases_.CanStream();
+
   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);
+
+  can_stream_ = expressions_.CanStream() && body_->can_stream();
+
   return this;
 }
 
 
 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;
 }
 
 
 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->can_stream_ = ifstmt->condition_->can_stream() &&
+                        ifstmt->then_->can_stream() &&
+                        ifstmt->otherwise_->can_stream();
+
   return ifstmt;
 }
 
 
 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->can_stream_ =
+      (ret->expression_ == NULL || ret->expression_->can_stream());
+
   return ret;
 }
 
 
 TryCatch* TryCatch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   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->can_stream_ = tc->body_->can_stream() && tc->catches_.CanStream();
+
   return tc;
 }
 
 
 Catch* Catch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   Catch* c = new Catch();
   c->kernel_offset_ = reader->offset();  // Catch has no tag.
   c->guard_ = DartType::ReadFrom(reader);
   c->exception_ =
       reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
   c->stack_trace_ =
       reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
   c->body_ = Statement::ReadFrom(reader);
   c->end_position_ = reader->max_position();
   c->position_ = reader->min_position();
 
+  c->can_stream_ = c->body_->can_stream();
+
   return c;
 }
 
 
 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->can_stream_ = tf->body_->can_stream() && tf->finalizer_->can_stream();
+
   return tf;
 }
 
 
 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->can_stream_ = stmt->expression_->can_stream();
+
   return stmt;
 }
 
 
 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kVariableDeclaration);
   return VariableDeclaration::ReadFromImpl(reader, true);
 }
@@ skipping 14 matching lines @@
   decl->type_ = DartType::ReadFrom(reader);
   decl->initializer_ = reader->ReadOptional<Expression>();
 
   // Go to next token position so it ends *after* the last potentially
   // debuggable position in the initializer.
   TokenPosition position = reader->max_position();
   if (position.IsReal()) position.Next();
   decl->end_position_ = position;
   reader->helper()->variables().Push(decl);
 
+  decl->can_stream_ =
+      (decl->initializer_ == NULL || decl->initializer_->can_stream());
+
   return decl;
 }
 
 
 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionDeclaration* decl = new FunctionDeclaration();
   decl->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   decl->position_ = reader->ReadPosition();
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
+
+  decl->can_stream_ = false;
+
   return decl;
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
   StringIndex name_index(reader->ReadUInt());
   if ((reader->StringLength(name_index) >= 1) &&
       (reader->CharacterAt(name_index, 0) == '_')) {
     intptr_t library_reference = reader->ReadCanonicalNameReference();
     return new Name(name_index, library_reference);
@@ skipping 88 matching lines @@
   return type;
 }
 
 
 FunctionType* FunctionType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionType* type = new FunctionType();
   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;
 }
 
 
 FunctionType* FunctionType::ReadFrom(Reader* reader, bool _is_simple_) {
   TRACE_READ_OFFSET();
   FunctionType* type = new FunctionType();
   ASSERT(_is_simple_);
   type->positional_parameters().ReadFromStatic<DartType>(reader);
   type->required_parameter_count_ = type->positional_parameters().length();
   type->return_type_ = DartType::ReadFrom(reader);
   return type;
 }
 
 
 TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterType* type = new TypeParameterType();
   type->parameter_ =
       reader->helper()->type_parameters().Lookup(reader->ReadUInt());
+  reader->ReadUInt();  // binary offset of parameter
   // There is an optional promoted bound, currently ignored.
   delete reader->ReadOptional<DartType>();
   return type;
 }
 
 
 VectorType* VectorType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VectorType* type = new VectorType();
   return type;
@@ skipping 40 matching lines @@
 
   int libraries = reader->ReadUInt();
   program->libraries().EnsureInitialized(libraries);
   for (intptr_t i = 0; i < libraries; i++) {
     program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader);
   }
 
   program->main_method_reference_ =
       Reference::ReadMemberFrom(reader, /*allow_null=*/true);
 
+  program->can_stream_ = false;
+
   return program;
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   FunctionNode* function = new FunctionNode();
   function->kernel_offset_ = reader->offset();  // FunctionNode has no tag.
   function->position_ = reader->ReadPosition();
   function->end_position_ = reader->ReadPosition();
   function->async_marker_ =
       static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
   function->dart_async_marker_ =
       static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
   function->type_parameters().ReadFrom(reader);
   function->required_parameter_count_ = reader->ReadUInt();
   function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>(
       reader);
   function->named_parameters().ReadFromStatic<VariableDeclarationImpl>(reader);
   function->return_type_ = DartType::ReadFrom(reader);
 
   LabelScope<ReaderHelper, BlockStack<LabeledStatement> > labels(
       reader->helper());
   VariableScope<ReaderHelper> vars(reader->helper());
   function->body_ = reader->ReadOptional<Statement>();
+
+  function->can_stream_ =
+      function->positional_parameters_.CanStream() &&
+      function->named_parameters_.CanStream() &&
+      (function->body_ == NULL || function->body_->can_stream());
+
   return function;
 }
 
 
 TypeParameter* TypeParameter::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
+  kernel_offset_ = reader->offset();
   name_index_ = StringIndex(reader->ReadUInt());
   bound_ = DartType::ReadFrom(reader);
   return this;
 }
 
 
 }  // namespace kernel
 
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)