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

runtime/vm/kernel_binary_flowgraph.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.
 
 #include "vm/kernel_binary_flowgraph.h"
 
+#include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
+#define T (type_translator_)
 #define I Isolate::Current()
 
+
+AbstractType& StreamingDartTypeTranslator::BuildType() {
+  BuildTypeInternal();
+
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  return dart::AbstractType::ZoneHandle(Z, result_.raw());
+}
+
+void StreamingDartTypeTranslator::BuildTypeInternal() {
+  Tag tag = builder_->ReadTag();
+  switch (tag) {
+    case kInvalidType:
+      result_ = ClassFinalizer::NewFinalizedMalformedType(
+          Error::Handle(Z),  // No previous error.
+          dart::Script::Handle(Z, dart::Script::null()),
+          TokenPosition::kNoSource, "[InvalidType] in Kernel IR.");
+      break;
+    case kDynamicType:
+      result_ = Object::dynamic_type().raw();
+      break;
+    case kVoidType:
+      result_ = Object::void_type().raw();
+      break;
+    case kInterfaceType:
+      BuildInterfaceType(false);
+      break;
+    case kSimpleInterfaceType:
+      BuildInterfaceType(true);
+      break;
+    case kFunctionType:
+      BuildFunctionType();
+      break;
+    case kSimpleFunctionType:
+      BuildSimpleFunctionType();
+      break;
+    case kTypeParameterType:
+      BuildTypeParameterType();
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+void StreamingDartTypeTranslator::BuildInterfaceType(bool simple) {
+  // NOTE: That an interface type like `T<A, B>` is considered to be
+  // malformed iff `T` is malformed.
+  //   => We therefore ignore errors in `A` or `B`.
+
+  CanonicalName* klass_name =
+      builder_->GetCanonicalName(builder_->ReadUInt());  // read klass_name.
+
+  intptr_t length;
+  if (simple) {
+    length = 0;
+  } else {
+    length = builder_->ReadListLength();  // read type_arguments list length.
+  }
+  const TypeArguments& type_arguments = BuildTypeArguments(length);
+
+  dart::Object& klass =
+      dart::Object::Handle(Z, H.LookupClassByKernelClass(klass_name));
+  result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
+  if (finalize_) {
+    ASSERT(active_class_->klass != NULL);
+    result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
+  }
+}
+
+void StreamingDartTypeTranslator::BuildFunctionType() {

[jensj, 2017/05/04 10:13:05]

BuildFunctionType and BuildSimpleFunctionType are basically the same. I have
locally rewritten to only have one (taking a "bool simple" argument).

+  intptr_t list_length =
+      builder_->ReadListLength();  // read type_parameters list length
+  intptr_t* type_parameters = new intptr_t[list_length];
+  for (int i = 0; i < list_length; ++i) {
+    type_parameters[i] = builder_->ReaderOffset();
+    builder_->ReadUInt();      // read string index (name).
+    builder_->SkipDartType();  // read dart type.
+  }
+
+  // The spec describes in section "19.1 Static Types":
+  //
+  //     Any use of a malformed type gives rise to a static warning. A
+  //     malformed type is then interpreted as dynamic by the static type
+  //     checker and the runtime unless explicitly specified otherwise.
+  //
+  // So we convert malformed return/parameter types to `dynamic`.
+  TypeParameterScope scope(this, type_parameters, list_length);
+
+  Function& signature_function = Function::ZoneHandle(
+      Z, Function::NewSignatureFunction(*active_class_->klass,
+                                        TokenPosition::kNoSource));
+
+  const intptr_t required_count =
+      builder_->ReadUInt();  // read required parameter count.
+  const intptr_t all_count =
+      builder_->ReadUInt();  // read total parameter count.
+
+  const Array& parameter_types =
+      Array::Handle(Z, Array::New(1 + all_count, Heap::kOld));
+  signature_function.set_parameter_types(parameter_types);
+  const Array& parameter_names =
+      Array::Handle(Z, Array::New(1 + all_count, Heap::kOld));
+  signature_function.set_parameter_names(parameter_names);
+
+  const intptr_t positional_count =
+      builder_->ReadListLength();  // read positional_parameters list length.
+  intptr_t pos = 0;
+  parameter_types.SetAt(pos, AbstractType::dynamic_type());
+  parameter_names.SetAt(pos, H.DartSymbol("_receiver_"));
+  ++pos;
+  for (intptr_t i = 0; i < positional_count; ++i, ++pos) {
+    BuildTypeInternal();  // read ith positional parameter.
+    if (result_.IsMalformed()) {
+      result_ = AbstractType::dynamic_type().raw();
+    }
+    parameter_types.SetAt(pos, result_);
+    parameter_names.SetAt(pos, H.DartSymbol("noname"));
+  }
+
+  const intptr_t named_count =
+      builder_->ReadListLength();  // read named_parameters list length.
+
+  // The additional first parameter is the receiver type (set to dynamic).
+  signature_function.set_num_fixed_parameters(1 + required_count);
+  signature_function.SetNumOptionalParameters(
+      all_count - required_count, positional_count > required_count);
+
+  for (intptr_t i = 0; i < named_count; ++i, ++pos) {
+    // read string reference (i.e. named_parameters[i].name).
+    dart::String& name = H.DartSymbol(builder_->ReadUInt());
+    BuildTypeInternal();  // read named_parameters[i].type.
+    if (result_.IsMalformed()) {
+      result_ = AbstractType::dynamic_type().raw();
+    }
+    parameter_types.SetAt(pos, result_);
+    parameter_names.SetAt(pos, name);
+  }
+
+  BuildTypeInternal();  // read return type.
+  if (result_.IsMalformed()) {
+    result_ = AbstractType::dynamic_type().raw();
+  }
+  signature_function.set_result_type(result_);
+
+  Type& signature_type =
+      Type::ZoneHandle(Z, signature_function.SignatureType());
+
+  if (finalize_) {
+    signature_type ^=
+        ClassFinalizer::FinalizeType(*active_class_->klass, signature_type);
+    // Do not refer to signature_function anymore, since it may have been
+    // replaced during canonicalization.
+    signature_function = Function::null();
+  }
+
+  result_ = signature_type.raw();
+}
+
+void StreamingDartTypeTranslator::BuildSimpleFunctionType() {
+  const intptr_t positional_count =
+      builder_->ReadListLength();  // read positional_parameters length.
+
+  // The spec describes in section "19.1 Static Types":
+  //
+  //     Any use of a malformed type gives rise to a static warning. A
+  //     malformed type is then interpreted as dynamic by the static type
+  //     checker and the runtime unless explicitly specified otherwise.
+  //
+  // So we convert malformed return/parameter types to `dynamic`.
+  TypeParameterScope scope(this, NULL, 0);
+
+  Function& signature_function = Function::ZoneHandle(
+      Z, Function::NewSignatureFunction(*active_class_->klass,
+                                        TokenPosition::kNoSource));
+
+  // The additional first parameter is the receiver type (set to dynamic).
+  signature_function.set_num_fixed_parameters(1 + positional_count);
+
+  const Array& parameter_types =
+      Array::Handle(Z, Array::New(1 + positional_count, Heap::kOld));
+  signature_function.set_parameter_types(parameter_types);
+  const Array& parameter_names =
+      Array::Handle(Z, Array::New(1 + positional_count, Heap::kOld));
+  signature_function.set_parameter_names(parameter_names);
+
+  intptr_t pos = 0;
+  parameter_types.SetAt(pos, AbstractType::dynamic_type());
+  parameter_names.SetAt(pos, H.DartSymbol("_receiver_"));
+  ++pos;
+  for (intptr_t i = 0; i < positional_count; ++i, ++pos) {
+    BuildTypeInternal();  // read ith positional parameter.
+
+    if (result_.IsMalformed()) {
+      result_ = AbstractType::dynamic_type().raw();
+    }
+    parameter_types.SetAt(pos, result_);
+    parameter_names.SetAt(pos, H.DartSymbol("noname"));
+  }
+
+  BuildTypeInternal();  // read return type.
+  if (result_.IsMalformed()) {
+    result_ = AbstractType::dynamic_type().raw();
+  }
+  signature_function.set_result_type(result_);
+
+  Type& signature_type =
+      Type::ZoneHandle(Z, signature_function.SignatureType());
+
+  if (finalize_) {
+    signature_type ^=
+        ClassFinalizer::FinalizeType(*active_class_->klass, signature_type);
+    // Do not refer to signature_function anymore, since it may have been
+    // replaced during canonicalization.
+    signature_function = Function::null();
+  }
+
+  result_ = signature_type.raw();
+}
+
+static intptr_t FindTypeParameterIndex(intptr_t* parameters,
+                                       intptr_t parameters_count,
+                                       intptr_t look_for) {
+  for (intptr_t i = 0; i < parameters_count; ++i) {
+    if (look_for == parameters[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+static intptr_t FindTypeParameterIndex(List<TypeParameter>* parameters,
+                                       intptr_t look_for) {
+  for (intptr_t i = 0; i < parameters->length(); ++i) {
+    if (look_for == (*parameters)[i]->kernel_offset()) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void StreamingDartTypeTranslator::BuildTypeParameterType() {
+  builder_->ReadUInt();                           // read parameter index.
+  intptr_t binary_offset = builder_->ReadUInt();  // read binary offset.
+  if (binary_offset == 0) {
+    // TODO(jensj): This doesn't appear to actually happen.
+    UNIMPLEMENTED();
+    return;
+  }
+
+  for (TypeParameterScope* scope = type_parameter_scope_; scope != NULL;
+       scope = scope->outer()) {
+    const intptr_t index = FindTypeParameterIndex(
+        scope->parameters(), scope->parameters_count(), binary_offset);
+    if (index >= 0) {
+      result_ ^= dart::Type::DynamicType();
+      return;
+    }
+  }
+
+  if ((active_class_->member != NULL) && active_class_->member->IsProcedure()) {
+    Procedure* procedure = Procedure::Cast(active_class_->member);
+    if ((procedure->function() != NULL) &&
+        (procedure->function()->type_parameters().length() > 0)) {
+      //
+      // WARNING: This is a little hackish:
+      //
+      // We have a static factory constructor. The kernel IR gives the factory
+      // constructor function it's own type parameters (which are equal in name
+      // and number to the ones of the enclosing class).
+      // I.e.,
+      //
+      //   class A<T> {
+      //     factory A.x() { return new B<T>(); }
+      //   }
+      //
+      //  is basically translated to this:
+      //
+      //   class A<T> {
+      //     static A.x<T'>() { return new B<T'>(); }
+      //   }
+      //
+      const intptr_t index = FindTypeParameterIndex(
+          &procedure->function()->type_parameters(), binary_offset);
+      if (index >= 0) {
+        if (procedure->kind() == Procedure::kFactory) {
+          // The index of the type parameter in [parameters] is
+          // the same index into the `klass->type_parameters()` array.
+          result_ ^= dart::TypeArguments::Handle(
+                         Z, active_class_->klass->type_parameters())
+                         .TypeAt(index);
+        } else {
+          result_ ^= dart::Type::DynamicType();
+        }
+        return;
+      }
+    }
+  }
+
+  ASSERT(active_class_->kernel_class != NULL);
+  List<TypeParameter>* parameters =
+      &active_class_->kernel_class->type_parameters();
+  const intptr_t index = FindTypeParameterIndex(parameters, binary_offset);
+  if (index >= 0) {
+    // The index of the type parameter in [parameters] is
+    // the same index into the `klass->type_parameters()` array.
+    result_ ^=
+        dart::TypeArguments::Handle(Z, active_class_->klass->type_parameters())
+            .TypeAt(index);
+    return;
+  }
+
+  UNREACHABLE();
+}
+
+const TypeArguments& StreamingDartTypeTranslator::BuildTypeArguments(
+    intptr_t length) {
+  bool only_dynamic = true;
+  intptr_t offset = builder_->ReaderOffset();
+  for (intptr_t i = 0; i < length; ++i) {
+    if (builder_->ReadTag() != kDynamicType) {  // read ith type's tag.
+      only_dynamic = false;
+      builder_->SetOffset(offset);
+      break;
+    }
+  }
+  TypeArguments& type_arguments = TypeArguments::ZoneHandle(Z);
+  if (!only_dynamic) {
+    type_arguments = TypeArguments::New(length);
+    for (intptr_t i = 0; i < length; ++i) {
+      BuildTypeInternal();  // read ith type.
+      if (!result_.IsDynamicType()) {
+        only_dynamic = false;
+      }
+      if (result_.IsMalformed()) {
+        type_arguments = TypeArguments::null();
+        return type_arguments;
+      }
+      type_arguments.SetTypeAt(i, result_);
+    }
+
+    if (finalize_) {
+      type_arguments = type_arguments.Canonicalize();
+    }
+  }
+  return type_arguments;
+}
+
+const TypeArguments&
+StreamingDartTypeTranslator::BuildInstantiatedTypeArguments(
+    const dart::Class& receiver_class,
+    intptr_t length) {
+  const TypeArguments& type_arguments = BuildTypeArguments(length);
+  if (type_arguments.IsNull()) return type_arguments;
+
+  // We make a temporary [Type] object and use `ClassFinalizer::FinalizeType` to
+  // finalize the argument types.
+  // (This can for example make the [type_arguments] vector larger)
+  Type& type = Type::Handle(
+      Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
+  if (finalize_) {
+    type ^=
+        ClassFinalizer::FinalizeType(*builder_->active_class()->klass, type);
+  }
+
+  const TypeArguments& instantiated_type_arguments =
+      TypeArguments::ZoneHandle(Z, type.arguments());
+  return instantiated_type_arguments;
+}
+
+
+const Type& StreamingDartTypeTranslator::ReceiverType(
+    const dart::Class& klass) {
+  ASSERT(!klass.IsNull());
+  ASSERT(!klass.IsTypedefClass());
+  // Note that if klass is _Closure, the returned type will be _Closure,
+  // and not the signature type.
+  Type& type = Type::ZoneHandle(Z, klass.CanonicalType());
+  if (!type.IsNull()) {
+    return type;
+  }
+  type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
+                   klass.token_pos());
+  if (klass.is_type_finalized()) {
+    type ^= ClassFinalizer::FinalizeType(klass, type);
+    klass.SetCanonicalType(type);
+  }
+  return type;
+}
+
+
 StreamingConstantEvaluator::StreamingConstantEvaluator(
     StreamingFlowGraphBuilder* builder,
     Zone* zone,
-    TranslationHelper* h,
-    DartTypeTranslator* type_translator)
+    TranslationHelper* helper,
+    StreamingDartTypeTranslator* type_translator)
     : builder_(builder),
       isolate_(Isolate::Current()),
       zone_(zone),
-      translation_helper_(*h),
-      // type_translator_(*type_translator),
+      translation_helper_(*helper),
+      type_translator_(*type_translator),
       script_(Script::Handle(
           zone,
           builder == NULL ? Script::null()
                           : builder_->parsed_function()->function().script())),
       result_(Instance::Handle(zone)) {}
 
 
-Instance& StreamingConstantEvaluator::EvaluateExpression() {
-  intptr_t offset = builder_->ReaderOffset();
-  if (!GetCachedConstant(offset, &result_)) {
+Instance& StreamingConstantEvaluator::EvaluateExpression(intptr_t offset,
+                                                         bool reset_position) {
+  bool got_cached = GetCachedConstant(offset, &result_);
+  if (!got_cached) {
+    intptr_t original_offset = builder_->ReaderOffset();
+    builder_->SetOffset(offset);
     uint8_t payload = 0;
-    Tag tag = builder_->ReadTag(&payload);
+    Tag tag = builder_->ReadTag(&payload);  // read tag.
     switch (tag) {
+      case kVariableGet:
+        EvaluateVariableGet();
+        break;
+      case kSpecializedVariableGet:
+        EvaluateVariableGet(payload);
+        break;
+      case kPropertyGet:
+        EvaluatePropertyGet();
+        break;
       case kStaticGet:
         EvaluateStaticGet();
         break;
+      case kMethodInvocation:
+        EvaluateMethodInvocation();
+        break;
+      case kStaticInvocation:
+      case kConstStaticInvocation:
+        EvaluateStaticInvocation();
+        break;
+      case kConstructorInvocation:
+      case kConstConstructorInvocation:
+        EvaluateConstructorInvocationInternal();
+        break;
+      case kNot:
+        EvaluateNot();
+        break;
+      case kLogicalExpression:
+        EvaluateLogicalExpression();
+        break;
+      case kConditionalExpression:
+        EvaluateConditionalExpression();
+        break;
+      case kStringConcatenation:
+        EvaluateStringConcatenation();
+        break;
       case kSymbolLiteral:
         EvaluateSymbolLiteral();
         break;
+      case kTypeLiteral:
+        EvaluateTypeLiteral();
+        break;
+      case kListLiteral:
+      case kConstListLiteral:
+        EvaluateListLiteralInternal();
+        break;
+      case kMapLiteral:
+      case kConstMapLiteral:
+        EvaluateMapLiteralInternal();
+        break;
+      case kLet:
+        EvaluateLet();
+        break;
+      case kBigIntLiteral:
+        EvaluateBigIntLiteral();
+        break;
+      case kStringLiteral:
+        EvaluateStringLiteral();
+        break;
+      case kSpecialIntLiteral:
+        EvaluateIntLiteral(payload);
+        break;
+      case kNegativeIntLiteral:
+        EvaluateIntLiteral(true);
+        break;
+      case kPositiveIntLiteral:
+        EvaluateIntLiteral(false);
+        break;
       case kDoubleLiteral:
         EvaluateDoubleLiteral();
         break;
+      case kTrueLiteral:
+        EvaluateBoolLiteral(true);
+        break;
+      case kFalseLiteral:
+        EvaluateBoolLiteral(false);
+        break;
+      case kNullLiteral:
+        EvaluateNullLiteral();
+        break;
       default:
         UNREACHABLE();
     }
 
     CacheConstantValue(offset, result_);
-  }
-  // We return a new `ZoneHandle` here on purpose: The intermediate language
-  // instructions do not make a copy of the handle, so we do it.
-  return dart::Instance::ZoneHandle(Z, result_.raw());
+    if (reset_position) builder_->SetOffset(original_offset);
+  }
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  return Instance::ZoneHandle(Z, result_.raw());
+}
+
+Instance& StreamingConstantEvaluator::EvaluateListLiteral(intptr_t offset,
+                                                          bool reset_position) {
+  bool got_cached = GetCachedConstant(offset, &result_);
+  if (!got_cached) {
+    intptr_t original_offset = builder_->ReaderOffset();
+    builder_->SetOffset(offset);
+    builder_->ReadTag();  // skip tag.
+    EvaluateListLiteralInternal();
+
+    CacheConstantValue(offset, result_);
+    if (reset_position) builder_->SetOffset(original_offset);
+  }
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  return Instance::ZoneHandle(Z, result_.raw());
+}
+
+Instance& StreamingConstantEvaluator::EvaluateMapLiteral(intptr_t offset,
+                                                         bool reset_position) {
+  bool got_cached = GetCachedConstant(offset, &result_);
+  if (!got_cached) {
+    intptr_t original_offset = builder_->ReaderOffset();
+    builder_->SetOffset(offset);
+    builder_->ReadTag();  // skip tag.
+    EvaluateMapLiteralInternal();
+
+    CacheConstantValue(offset, result_);
+    if (reset_position) builder_->SetOffset(original_offset);
+  }
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  return Instance::ZoneHandle(Z, result_.raw());
+}
+
+Instance& StreamingConstantEvaluator::EvaluateConstructorInvocation(
+    intptr_t offset,
+    bool reset_position) {
+  bool got_cached = GetCachedConstant(offset, &result_);
+  if (!got_cached) {
+    intptr_t original_offset = builder_->ReaderOffset();
+    builder_->SetOffset(offset);
+    builder_->ReadTag();  // skip tag.
+    EvaluateConstructorInvocationInternal();
+
+    CacheConstantValue(offset, result_);
+    if (reset_position) builder_->SetOffset(original_offset);
+  }
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  return Instance::ZoneHandle(Z, result_.raw());
+}
+
+Object& StreamingConstantEvaluator::EvaluateExpressionSafe(intptr_t offset) {
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    return EvaluateExpression(offset);
+  } else {
+    Thread* thread = H.thread();
+    Error& error = Error::Handle(Z);
+    error = thread->sticky_error();
+    thread->clear_sticky_error();
+    return error;
+  }
+}
+
+void StreamingConstantEvaluator::EvaluateVariableGet() {
+  // When we see a [VariableGet] the corresponding [VariableDeclaration] must've
+  // been executed already. It therefore must have a constant object associated
+  // with it.
+  builder_->ReadPosition();  // read position.
+  intptr_t variable_kernel_position =
+      builder_->ReadUInt();          // read kernel position.
+  builder_->ReadUInt();              // read relative variable index.
+  builder_->SkipOptionalDartType();  // read promoted type.
+  LocalVariable* variable = builder_->LookupVariable(variable_kernel_position);
+  ASSERT(variable->IsConst());
+  result_ = variable->ConstValue()->raw();
+}
+
+void StreamingConstantEvaluator::EvaluateVariableGet(uint8_t payload) {
+  // When we see a [VariableGet] the corresponding [VariableDeclaration] must've
+  // been executed already. It therefore must have a constant object associated
+  // with it.
+  builder_->ReadPosition();  // read position.
+  intptr_t variable_kernel_position =
+      builder_->ReadUInt();  // read kernel position.
+  LocalVariable* variable = builder_->LookupVariable(variable_kernel_position);
+  ASSERT(variable->IsConst());
+  result_ = variable->ConstValue()->raw();
+}
+
+void StreamingConstantEvaluator::EvaluatePropertyGet() {
+  builder_->ReadPosition();  // read position.
+  intptr_t expression_offset = builder_->ReaderOffset();
+  builder_->SkipExpression();  // read receiver.
+  intptr_t name_string_index = builder_->ReadNameAsStringIndex();  // read name.
+  builder_->ReadUInt();  // Read unused "interface_target_reference".
+
+  if (H.StringEquals(name_string_index, "length")) {
+    EvaluateExpression(expression_offset);
+    if (result_.IsString()) {
+      const dart::String& str =
+          dart::String::Handle(Z, dart::String::RawCast(result_.raw()));
+      result_ = Integer::New(str.Length());
+    } else {
+      H.ReportError(
+          "Constant expressions can only call "
+          "'length' on string constants.");
+    }
+  } else {
+    UNREACHABLE();
+  }
 }
 
 void StreamingConstantEvaluator::EvaluateStaticGet() {
-  builder_->ReadPosition();
-  int canonical_name_index = builder_->ReadUInt();
+  builder_->ReadPosition();  // read position.
+  intptr_t canonical_name_index =
+      builder_->ReadUInt();  // read target_reference.
   CanonicalName* target = builder_->GetCanonicalName(canonical_name_index);
 
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
     if (field.StaticValue() == Object::sentinel().raw() ||
         field.StaticValue() == Object::transition_sentinel().raw()) {
       field.EvaluateInitializer();
       result_ = field.StaticValue();
       result_ = H.Canonicalize(result_);
@@ skipping 12 matching lines @@
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
     } else if (H.IsGetter(target)) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
+void StreamingConstantEvaluator::EvaluateMethodInvocation() {
+  builder_->ReadPosition();  // read position.
+  // This method call wasn't cached, so receiver et al. isn't cached either.
+  const dart::Instance& receiver =
+      EvaluateExpression(builder_->ReaderOffset(), false);  // read receiver.
+  dart::Class& klass = dart::Class::Handle(
+      Z, isolate_->class_table()->At(receiver.GetClassId()));
+  ASSERT(!klass.IsNull());
+
+  // Search the superclass chain for the selector.
+  dart::Function& function = dart::Function::Handle(Z);
+  const dart::String& method_name =
+      builder_->ReadNameAsMethodName();  // read name.
+  while (!klass.IsNull()) {
+    function = klass.LookupDynamicFunctionAllowPrivate(method_name);
+    if (!function.IsNull()) break;
+    klass = klass.SuperClass();
+  }
+
+  // The frontend should guarantee that [MethodInvocation]s inside constant
+  // expressions are always valid.
+  ASSERT(!function.IsNull());
+
+  // Read first parts of arguments: count and list of types.
+  intptr_t argument_count = builder_->PeekArgumentsCount();
+  // Dart does not support generic methods yet.
+  ASSERT(builder_->PeekArgumentsTypeCount() == 0);
+  builder_->SkipArgumentsBeforeActualArguments();
+
+  // Run the method and canonicalize the result.
+  const Object& result = RunFunction(function, argument_count, &receiver, NULL);
+  result_ ^= result.raw();
+  result_ = H.Canonicalize(result_);
+
+  builder_->ReadUInt();  // read "interface_target_reference"
+}
+
+void StreamingConstantEvaluator::EvaluateStaticInvocation() {
+  builder_->ReadPosition();  // read position.
+  CanonicalName* procedue_reference = builder_->GetCanonicalName(
+      builder_->ReadUInt());  // read procedure reference.
+
+  const Function& function = Function::ZoneHandle(
+      Z, H.LookupStaticMethodByKernelProcedure(procedue_reference));
+  dart::Class& klass = dart::Class::Handle(Z, function.Owner());
+
+  intptr_t argument_count =
+      builder_->ReadUInt();  // read arguments part #1: arguments count.
+
+  // Build the type arguments vector (if necessary).
+  const TypeArguments* type_arguments =
+      TranslateTypeArguments(function, &klass);  // read argument types.
+
+  // read positional and named parameters.
+  const Object& result =
+      RunFunction(function, argument_count, NULL, type_arguments);
+  result_ ^= result.raw();
+  result_ = H.Canonicalize(result_);
+}
+
+void StreamingConstantEvaluator::EvaluateConstructorInvocationInternal() {
+  builder_->ReadPosition();  // read position.
+
+  CanonicalName* target =
+      builder_->GetCanonicalName(builder_->ReadUInt());  // read target.
+  const Function& constructor =
+      Function::Handle(Z, H.LookupConstructorByKernelConstructor(target));
+  dart::Class& klass = dart::Class::Handle(Z, constructor.Owner());
+
+  intptr_t argument_count =
+      builder_->ReadUInt();  // read arguments part #1: arguments count.
+
+  // Build the type arguments vector (if necessary).
+  const TypeArguments* type_arguments =
+      TranslateTypeArguments(constructor, &klass);  // read argument types.
+
+  // Prepare either the instance or the type argument vector for the constructor
+  // call.
+  Instance* receiver = NULL;
+  const TypeArguments* type_arguments_argument = NULL;
+  if (!constructor.IsFactory()) {
+    receiver = &Instance::ZoneHandle(Z, Instance::New(klass, Heap::kOld));
+    if (type_arguments != NULL) {
+      receiver->SetTypeArguments(*type_arguments);
+    }
+  } else {
+    type_arguments_argument = type_arguments;
+  }
+
+  // read positional and named parameters.
+  const Object& result = RunFunction(constructor, argument_count, receiver,
+                                     type_arguments_argument);
+
+  if (constructor.IsFactory()) {
+    // Factories return the new object.
+    result_ ^= result.raw();
+    result_ = H.Canonicalize(result_);
+  } else {
+    ASSERT(!receiver->IsNull());
+    result_ = H.Canonicalize(*receiver);
+  }
+}
+
+void StreamingConstantEvaluator::EvaluateNot() {
+  result_ ^= Bool::Get(!EvaluateBooleanExpressionHere()).raw();
+}
+
+void StreamingConstantEvaluator::EvaluateLogicalExpression() {
+  bool left = EvaluateBooleanExpressionHere();  // read left.
+  LogicalOperator op =
+      static_cast<LogicalOperator>(builder_->ReadByte());  // read operator.
+  if (op == kAnd) {
+    if (left) {
+      EvaluateBooleanExpressionHere();  // read right.
+    } else {
+      builder_->SkipExpression();  // read right.
+    }
+  } else {
+    ASSERT(op == kOr);
+    if (!left) {
+      EvaluateBooleanExpressionHere();  // read right.
+    } else {
+      builder_->SkipExpression();  // read right.
+    }
+  }
+}
+
+void StreamingConstantEvaluator::EvaluateConditionalExpression() {
+  bool condition = EvaluateBooleanExpressionHere();
+  if (condition) {
+    EvaluateExpression(builder_->ReaderOffset(), false);  // read then.
+    builder_->SkipExpression();                           // read otherwise.
+  } else {
+    builder_->SkipExpression();                           // read then.
+    EvaluateExpression(builder_->ReaderOffset(), false);  // read otherwise.
+  }
+  builder_->SkipOptionalDartType();  // read unused static type.
+}
+
+void StreamingConstantEvaluator::EvaluateStringConcatenation() {
+  builder_->ReadPosition();                      // read position.
+  intptr_t length = builder_->ReadListLength();  // read list length.
+
+  bool all_string = true;
+  const Array& strings = Array::Handle(Z, Array::New(length));
+  for (intptr_t i = 0; i < length; ++i) {
+    EvaluateExpression(builder_->ReaderOffset(), false);
+    strings.SetAt(i, result_);
+    all_string = all_string && result_.IsString();
+  }
+  if (all_string) {
+    result_ = dart::String::ConcatAll(strings, Heap::kOld);
+    result_ = H.Canonicalize(result_);
+  } else {
+    // Get string interpolation function.
+    const dart::Class& cls = dart::Class::Handle(
+        Z, dart::Library::LookupCoreClass(Symbols::StringBase()));
+    ASSERT(!cls.IsNull());
+    const Function& func = Function::Handle(
+        Z, cls.LookupStaticFunction(
+               dart::Library::PrivateCoreLibName(Symbols::Interpolate())));
+    ASSERT(!func.IsNull());
+
+    // Build argument array to pass to the interpolation function.
+    const Array& interpolate_arg = Array::Handle(Z, Array::New(1, Heap::kOld));
+    interpolate_arg.SetAt(0, strings);
+
+    // Run and canonicalize.
+    const Object& result =
+        RunFunction(func, interpolate_arg, Array::null_array());
+    result_ = H.Canonicalize(dart::String::Cast(result));
+  }
+}
 
 void StreamingConstantEvaluator::EvaluateSymbolLiteral() {
-  int str_index = builder_->ReadUInt();
+  intptr_t str_index = builder_->ReadUInt();  // read index into string table.
   const dart::String& symbol_value = H.DartSymbol(str_index);
 
   const dart::Class& symbol_class =
       dart::Class::ZoneHandle(Z, I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
   const dart::Function& symbol_constructor = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!symbol_constructor.IsNull());
   result_ ^= EvaluateConstConstructorCall(
       symbol_class, TypeArguments::Handle(Z), symbol_constructor, symbol_value);
 }
 
+void StreamingConstantEvaluator::EvaluateTypeLiteral() {
+  const AbstractType& type = T.BuildType();
+  if (type.IsMalformed()) {
+    H.ReportError("Malformed type literal in constant expression.");
+  }
+  result_ = type.raw();
+}
+
+void StreamingConstantEvaluator::EvaluateListLiteralInternal() {
+  builder_->ReadPosition();  // read position.
+  const TypeArguments& type_arguments = T.BuildTypeArguments(1);  // read type.
+  intptr_t length = builder_->ReadListLength();  // read list length.
+  const Array& const_list =
+      Array::ZoneHandle(Z, Array::New(length, Heap::kOld));
+  const_list.SetTypeArguments(type_arguments);
+  for (intptr_t i = 0; i < length; ++i) {
+    const Instance& expression = EvaluateExpression(
+        builder_->ReaderOffset(), false);  // read ith expression.
+    const_list.SetAt(i, expression);
+  }
+  const_list.MakeImmutable();
+  result_ = H.Canonicalize(const_list);
+}
+
+void StreamingConstantEvaluator::EvaluateMapLiteralInternal() {
+  builder_->ReadPosition();  // read position.
+  const TypeArguments& type_arguments = T.BuildTypeArguments(2);
+
+  intptr_t length = builder_->ReadListLength();  // read length of entries.
+
+  // This wasn't cached, so content isn't cached either.
+  Array& const_kv_array =
+      Array::ZoneHandle(Z, Array::New(2 * length, Heap::kOld));
+  for (intptr_t i = 0; i < length; ++i) {
+    const_kv_array.SetAt(2 * i + 0, EvaluateExpression(builder_->ReaderOffset(),
+                                                       false));  // read key.
+    const_kv_array.SetAt(2 * i + 1, EvaluateExpression(builder_->ReaderOffset(),
+                                                       false));  // read value.
+  }
+
+  const_kv_array.MakeImmutable();
+  const_kv_array ^= H.Canonicalize(const_kv_array);
+
+  const dart::Class& map_class = dart::Class::Handle(
+      Z, dart::Library::LookupCoreClass(Symbols::ImmutableMap()));
+  ASSERT(!map_class.IsNull());
+  ASSERT(map_class.NumTypeArguments() == 2);
+
+  const dart::Field& field = dart::Field::Handle(
+      Z, map_class.LookupInstanceFieldAllowPrivate(H.DartSymbol("_kvPairs")));
+  ASSERT(!field.IsNull());
+
+  // NOTE: This needs to be kept in sync with `runtime/lib/immutable_map.dart`!
+  result_ = Instance::New(map_class, Heap::kOld);
+  ASSERT(!result_.IsNull());
+  result_.SetTypeArguments(type_arguments);
+  result_.SetField(field, const_kv_array);
+  result_ = H.Canonicalize(result_);
+}
+
+void StreamingConstantEvaluator::EvaluateLet() {
+  intptr_t kernel_position = builder_->ReaderOffset();
+  LocalVariable* local = builder_->LookupVariable(kernel_position);
+
+  // read variable declaration.
+  builder_->ReadPosition();       // read position.
+  builder_->ReadPosition();       // read equals position.
+  builder_->ReadFlags();          // read flags.
+  builder_->ReadUInt();           // read name index.
+  builder_->SkipDartType();       // read type.
+  Tag tag = builder_->ReadTag();  // read (first part of) initializer.
+  if (tag == kNothing) {
+    local->SetConstValue(Instance::ZoneHandle(Z, dart::Instance::null()));
+  } else {
+    local->SetConstValue(EvaluateExpression(builder_->ReaderOffset(), false));
+  }
+
+  // read body
+  EvaluateExpression(builder_->ReaderOffset(), false);
+}
+
+void StreamingConstantEvaluator::EvaluateBigIntLiteral() {
+  const dart::String& value =
+      H.DartString(builder_->ReadUInt());  // read string reference.
+  result_ = Integer::New(value, Heap::kOld);
+  result_ = H.Canonicalize(result_);
+}
+
+void StreamingConstantEvaluator::EvaluateStringLiteral() {
+  intptr_t str_index = builder_->ReadUInt();  // read string reference.
+  result_ = H.DartSymbol(str_index).raw();
+}
+
+void StreamingConstantEvaluator::EvaluateIntLiteral(uint8_t payload) {
+  int64_t value = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
+  result_ = dart::Integer::New(value, Heap::kOld);
+  result_ = H.Canonicalize(result_);
+}
+
+void StreamingConstantEvaluator::EvaluateIntLiteral(bool is_negative) {
+  int64_t value = is_negative ? -static_cast<int64_t>(builder_->ReadUInt())
+                              : builder_->ReadUInt();  // read value.
+  result_ = dart::Integer::New(value, Heap::kOld);
+  result_ = H.Canonicalize(result_);
+}
 
 void StreamingConstantEvaluator::EvaluateDoubleLiteral() {
-  int str_index = builder_->ReadUInt();
-  result_ = dart::Double::New(H.DartString(str_index), Heap::kOld);
-  result_ = H.Canonicalize(result_);
-}
-
+  intptr_t str_index = builder_->ReadUInt();  // read index into string table.
+  result_ = Double::New(H.DartString(str_index), Heap::kOld);
+  result_ = H.Canonicalize(result_);
+}
+
+void StreamingConstantEvaluator::EvaluateBoolLiteral(bool value) {
+  result_ = dart::Bool::Get(value).raw();
+}
+
+void StreamingConstantEvaluator::EvaluateNullLiteral() {
+  result_ = dart::Instance::null();
+}
+
+// This depends on being about to read the list of positionals on arguments.
+const Object& StreamingConstantEvaluator::RunFunction(
+    const Function& function,
+    intptr_t argument_count,
+    const Instance* receiver,
+    const TypeArguments* type_args) {
+  // We do not support generic methods yet.
+  ASSERT((receiver == NULL) || (type_args == NULL));
+  intptr_t extra_arguments =
+      (receiver != NULL ? 1 : 0) + (type_args != NULL ? 1 : 0);
+
+  // Build up arguments.
+  const Array& arguments =
+      Array::ZoneHandle(Z, Array::New(extra_arguments + argument_count));
+  intptr_t pos = 0;
+  if (receiver != NULL) {
+    arguments.SetAt(pos++, *receiver);
+  }
+  if (type_args != NULL) {
+    arguments.SetAt(pos++, *type_args);
+  }
+
+  // List of positional.
+  intptr_t list_length = builder_->ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    EvaluateExpression(builder_->ReaderOffset(),
+                       false);  // read ith expression.
+    arguments.SetAt(pos++, result_);
+  }
+
+  // List of named.
+  list_length = builder_->ReadListLength();  // read list length.
+  const Array& names = Array::ZoneHandle(Z, Array::New(list_length));
+  for (intptr_t i = 0; i < list_length; ++i) {
+    dart::String& name =
+        H.DartSymbol(builder_->ReadUInt());  // read ith name index.
+    names.SetAt(i, name);
+    EvaluateExpression(builder_->ReaderOffset(),
+                       false);  // read ith expression.
+    arguments.SetAt(pos++, result_);
+  }
+
+  return RunFunction(function, arguments, names);
+}
+
+const Object& StreamingConstantEvaluator::RunFunction(const Function& function,
+                                                      const Array& arguments,
+                                                      const Array& names) {
+  const Array& args_descriptor =
+      Array::Handle(Z, ArgumentsDescriptor::New(arguments.Length(), names));
+  const Object& result = Object::Handle(
+      Z, DartEntry::InvokeFunction(function, arguments, args_descriptor));
+  if (result.IsError()) {
+    H.ReportError(Error::Cast(result), "error evaluating constant constructor");
+  }
+  return result;
+}
 
 RawObject* StreamingConstantEvaluator::EvaluateConstConstructorCall(
     const dart::Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
@@ skipping 20 matching lines @@
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(constructor, arg_values, args_descriptor));
   ASSERT(!result.IsError());
   if (constructor.IsFactory()) {
     // The factory method returns the allocated object.
     instance ^= result.raw();
   }
   return H.Canonicalize(instance);
 }
 
+const TypeArguments* StreamingConstantEvaluator::TranslateTypeArguments(
+    const Function& target,
+    dart::Class* target_klass) {
+  intptr_t types_count = builder_->ReadListLength();  // read types count.
+
+  const TypeArguments* type_arguments = NULL;
+  if (types_count > 0) {
+    type_arguments = &T.BuildInstantiatedTypeArguments(
+        *target_klass, types_count);  // read types.
+
+    if (!(type_arguments->IsNull() || type_arguments->IsInstantiated())) {
+      H.ReportError("Type must be constant in const constructor.");
+    }
+  } else if (target.IsFactory() && type_arguments == NULL) {
+    // All factories take a type arguments vector as first argument (independent
+    // of whether the class is generic or not).
+    type_arguments = &TypeArguments::ZoneHandle(Z, TypeArguments::null());
+  }
+  return type_arguments;
+}
+
+bool StreamingConstantEvaluator::EvaluateBooleanExpressionHere() {
+  EvaluateExpression(builder_->ReaderOffset(), false);
+  AssertBoolInCheckedMode();
+  return result_.raw() == Bool::True().raw();
+}
+
 bool StreamingConstantEvaluator::GetCachedConstant(intptr_t kernel_offset,
                                                    Instance* value) {
   if (builder_ == NULL) return false;
 
   const Function& function = builder_->parsed_function()->function();
   if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return false;
   }
 
   bool is_present = false;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     return false;
   }
   KernelConstantsMap constants(script_.compile_time_constants());
   *value ^= constants.GetOrNull(kernel_offset, &is_present);
   // Mutator compiler thread may add constants while background compiler
   // is running, and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
-    H.thread()->compiler_stats()->num_const_cache_hits++;
+    ++H.thread()->compiler_stats()->num_const_cache_hits;
   }
   return is_present;
 }
 
 
 void StreamingConstantEvaluator::CacheConstantValue(intptr_t kernel_offset,
                                                     const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
 
   if (builder_ == NULL) return;
@@ skipping 10 matching lines @@
     const Array& array = Array::Handle(
         HashTables::New<KernelConstantsMap>(kInitialConstMapSize, Heap::kNew));
     script_.set_compile_time_constants(array);
   }
   KernelConstantsMap constants(script_.compile_time_constants());
   constants.InsertNewOrGetValue(kernel_offset, value);
   script_.set_compile_time_constants(constants.Release());
 }
 
 
-Fragment StreamingFlowGraphBuilder::BuildAt(intptr_t kernel_offset) {
+Fragment StreamingFlowGraphBuilder::BuildExpressionAt(intptr_t kernel_offset) {
   SetOffset(kernel_offset);
+  return BuildExpression();  // read expression.
+}
 
+Fragment StreamingFlowGraphBuilder::BuildExpression() {
   uint8_t payload = 0;
-  Tag tag = ReadTag(&payload);
+  Tag tag = ReadTag(&payload);  // read tag.
   switch (tag) {
     case kInvalidExpression:
       return BuildInvalidExpression();
-    //    case kVariableGet:
-    //      return VariableGet::ReadFrom(reader_);
-    //    case kSpecializedVariableGet:
-    //      return VariableGet::ReadFrom(reader_, payload);
-    //    case kVariableSet:
-    //      return VariableSet::ReadFrom(reader_);
-    //    case kSpecializedVariableSet:
-    //      return VariableSet::ReadFrom(reader_, payload);
-    //    case kPropertyGet:
-    //      return PropertyGet::ReadFrom(reader_);
-    //    case kPropertySet:
-    //      return PropertySet::ReadFrom(reader_);
-    //    case kDirectPropertyGet:
-    //      return DirectPropertyGet::ReadFrom(reader_);
-    //    case kDirectPropertySet:
-    //      return DirectPropertySet::ReadFrom(reader_);
+    case kVariableGet:
+      return BuildVariableGet();
+    case kSpecializedVariableGet:
+      return BuildVariableGet(payload);
+    case kVariableSet:
+      return BuildVariableSet();
+    case kSpecializedVariableSet:
+      return BuildVariableSet(payload);
+    case kPropertyGet:
+      return BuildPropertyGet();
+    case kPropertySet:
+      return BuildPropertySet();
+    case kDirectPropertyGet:
+      return BuildDirectPropertyGet();
+    case kDirectPropertySet:
+      return BuildDirectPropertySet();
     case kStaticGet:
       return BuildStaticGet();
-    //    case kStaticSet:
-    //      return StaticSet::ReadFrom(reader_);
-    //    case kMethodInvocation:
-    //      return MethodInvocation::ReadFrom(reader_);
-    //    case kDirectMethodInvocation:
-    //      return DirectMethodInvocation::ReadFrom(reader_);
-    //    case kStaticInvocation:
-    //      return StaticInvocation::ReadFrom(reader_, false);
-    //    case kConstStaticInvocation:
-    //      return StaticInvocation::ReadFrom(reader_, true);
-    //    case kConstructorInvocation:
-    //      return ConstructorInvocation::ReadFrom(reader_, false);
-    //    case kConstConstructorInvocation:
-    //      return ConstructorInvocation::ReadFrom(reader_, true);
-    //    case kNot:
-    //      return Not::ReadFrom(reader_);
-    //    case kLogicalExpression:
-    //      return LogicalExpression::ReadFrom(reader_);
-    //    case kConditionalExpression:
-    //      return ConditionalExpression::ReadFrom(reader_);
-    //    case kStringConcatenation:
-    //      return StringConcatenation::ReadFrom(reader_);
-    //    case kIsExpression:
-    //      return IsExpression::ReadFrom(reader_);
-    //    case kAsExpression:
-    //      return AsExpression::ReadFrom(reader_);
+    case kStaticSet:
+      return BuildStaticSet();
+    case kMethodInvocation:
+      return BuildMethodInvocation();
+    case kDirectMethodInvocation:
+      return BuildDirectMethodInvocation();
+    case kStaticInvocation:
+      return BuildStaticInvocation(false);
+    case kConstStaticInvocation:
+      return BuildStaticInvocation(true);
+    case kConstructorInvocation:
+      return BuildConstructorInvocation(false);
+    case kConstConstructorInvocation:
+      return BuildConstructorInvocation(true);
+    case kNot:
+      return BuildNot();
+    case kLogicalExpression:
+      return BuildLogicalExpression();
+    case kConditionalExpression:
+      return BuildConditionalExpression();
+    case kStringConcatenation:
+      return BuildStringConcatenation();
+    case kIsExpression:
+      return BuildIsExpression();
+    case kAsExpression:
+      return BuildAsExpression();
     case kSymbolLiteral:
       return BuildSymbolLiteral();
-    //    case kTypeLiteral:
-    //      return TypeLiteral::ReadFrom(reader_);
+    case kTypeLiteral:
+      return BuildTypeLiteral();
     case kThisExpression:
       return BuildThisExpression();
     case kRethrow:
       return BuildRethrow();
-    //    case kThrow:
-    //      return Throw::ReadFrom(reader_);
-    //    case kListLiteral:
-    //      return ListLiteral::ReadFrom(reader_, false);
-    //    case kConstListLiteral:
-    //      return ListLiteral::ReadFrom(reader_, true);
-    //    case kMapLiteral:
-    //      return MapLiteral::ReadFrom(reader_, false);
-    //    case kConstMapLiteral:
-    //      return MapLiteral::ReadFrom(reader_, true);
-    //    case kAwaitExpression:
-    //      return AwaitExpression::ReadFrom(reader_);
-    //    case kFunctionExpression:
-    //      return FunctionExpression::ReadFrom(reader_);
-    //    case kLet:
-    //      return Let::ReadFrom(reader_);
+    case kThrow:
+      return BuildThrow();
+    case kListLiteral:
+      return BuildListLiteral(false);
+    case kConstListLiteral:
+      return BuildListLiteral(true);
+    case kMapLiteral:
+      return BuildMapLiteral(false);
+    case kConstMapLiteral:
+      return BuildMapLiteral(true);
+    case kFunctionExpression:
+      // TODO(jensj)
+      UNIMPLEMENTED();
+      return Fragment();
+    case kLet:
+      return BuildLet();
     case kBigIntLiteral:
       return BuildBigIntLiteral();
     case kStringLiteral:
       return BuildStringLiteral();
     case kSpecialIntLiteral:
       return BuildIntLiteral(payload);
     case kNegativeIntLiteral:
       return BuildIntLiteral(true);
     case kPositiveIntLiteral:
       return BuildIntLiteral(false);
     case kDoubleLiteral:
       return BuildDoubleLiteral();
     case kTrueLiteral:
       return BuildBoolLiteral(true);
     case kFalseLiteral:
       return BuildBoolLiteral(false);
     case kNullLiteral:
       return BuildNullLiteral();
     default:
       UNREACHABLE();
   }
 
   return Fragment();
 }
 
+Fragment StreamingFlowGraphBuilder::BuildStatementAt(intptr_t kernel_offset) {
+  SetOffset(kernel_offset);
+  return BuildStatement();  // read statement.
+}
+
+Fragment StreamingFlowGraphBuilder::BuildStatement() {
+  Tag tag = ReadTag();  // read tag.
+  switch (tag) {
+    case kInvalidStatement:
+      return BuildInvalidStatement();
+    case kExpressionStatement:
+      return BuildExpressionStatement();
+    case kBlock:
+      return BuildBlock();
+    case kEmptyStatement:
+      return BuildEmptyStatement();
+    case kAssertStatement:
+      return BuildAssertStatement();
+    case kLabeledStatement:
+      return BuildLabeledStatement();
+    case kBreakStatement:
+      return BuildBreakStatement();
+    case kWhileStatement:
+      return BuildWhileStatement();
+    case kDoStatement:
+      return BuildDoStatement();
+    case kForStatement:
+      return BuildForStatement();
+    case kForInStatement:
+      return BuildForInStatement(false);
+    case kAsyncForInStatement:
+      return BuildForInStatement(true);
+    case kSwitchStatement:
+      return BuildSwitchStatement();
+    case kContinueSwitchStatement:
+      return BuildContinueSwitchStatement();
+    case kIfStatement:
+      return BuildIfStatement();
+    case kReturnStatement:
+      return BuildReturnStatement();
+    case kTryCatch:
+      return BuildTryCatch();
+    case kTryFinally:
+      return BuildTryFinally();
+    case kYieldStatement:
+      return BuildYieldStatement();
+    case kVariableDeclaration:
+      return BuildVariableDeclaration(true);
+    case kFunctionDeclaration:
+      // TODO(jensj)
+      UNIMPLEMENTED();
+      return Fragment();
+    default:
+      UNREACHABLE();
+  }
+  return Fragment();
+}
+
+void StreamingFlowGraphBuilder::SkipStatement() {
+  Tag tag = ReadTag();  // read tag.
+  switch (tag) {
+    case kInvalidStatement:
+      return;
+    case kExpressionStatement:
+      SkipExpression();  // read expression.
+      return;
+    case kBlock: {
+      intptr_t list_length = ReadListLength();  // read number of statements.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipStatement();  // read ith statement.
+      }
+      return;
+    }
+    case kEmptyStatement:
+      return;
+    case kAssertStatement: {
+      SkipExpression();     // Read condition.
+      Tag tag = ReadTag();  // read (first part of) message.
+      if (tag == kSomething) {
+        SkipExpression();  // read (rest of) message.
+      }
+      return;
+    }
+    case kLabeledStatement:
+      SkipStatement();  // read body.
+      return;
+    case kBreakStatement:
+      ReadPosition();  // read position.
+      ReadUInt();      // read target_index.
+      return;
+    case kWhileStatement:
+      SkipExpression();  // read condition.
+      SkipStatement();   // read body.
+      return;
+    case kDoStatement:
+      SkipStatement();   // read body.
+      SkipExpression();  // read condition.
+      return;
+    case kForStatement: {
+      intptr_t list_length = ReadListLength();  // read number of variables.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipVariableDeclaration();  // read ith variable.
+      }
+      Tag tag = ReadTag();  // Read first part of condition.
+      if (tag == kSomething) {
+        SkipExpression();  // read rest of condition.
+      }
+      list_length = ReadListLength();  // read number of updates.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipExpression();  // read ith update.
+      }
+      SkipStatement();  // read body.
+      return;
+    }
+    case kForInStatement:
+    case kAsyncForInStatement:
+      ReadPosition();             // read position.
+      SkipVariableDeclaration();  // read variable.
+      SkipExpression();           // read iterable.
+      SkipStatement();            // read body.
+      return;
+    case kSwitchStatement: {
+      SkipExpression();                  // read condition.
+      int num_cases = ReadListLength();  // read number of cases.
+      for (intptr_t i = 0; i < num_cases; ++i) {
+        int num_expressions = ReadListLength();  // read number of expressions.
+        for (intptr_t j = 0; j < num_expressions; ++j) {
+          ReadPosition();    // read jth position.
+          SkipExpression();  // read jth expression.
+        }
+        ReadBool();       // read is_default.
+        SkipStatement();  // read body.
+      }
+      return;
+    }
+    case kContinueSwitchStatement:
+      ReadUInt();  // read target_index.
+      return;
+    case kIfStatement:
+      SkipExpression();  // read condition.
+      SkipStatement();   // read then.
+      SkipStatement();   // read otherwise.
+      return;
+    case kReturnStatement: {
+      ReadPosition();       // read position
+      Tag tag = ReadTag();  // read (first part of) expression.
+      if (tag == kSomething) {
+        SkipExpression();  // read (rest of) expression.
+      }
+      return;
+    }
+    case kTryCatch: {
+      SkipStatement();  // read body.
+      ReadBool();       // read any_catch_needs_stack_trace.
+      intptr_t num_matches = ReadListLength();  // read number of catches.
+      for (intptr_t i = 0; i < num_matches; ++i) {
+        SkipDartType();   // read guard.
+        tag = ReadTag();  // read first part of exception.
+        if (tag == kSomething) {
+          SkipVariableDeclaration();  // read exception.
+        }
+        tag = ReadTag();  // read first part of stack trace.
+        if (tag == kSomething) {
+          SkipVariableDeclaration();  // read stack trace.
+        }
+        SkipStatement();  // read body.
+      }
+      return;
+    }
+    case kTryFinally:
+      SkipStatement();  // read body.
+      SkipStatement();  // read finalizer.
+      return;
+    case kYieldStatement:
+      ReadPosition();    // read position.
+      ReadByte();        // read flags.
+      SkipExpression();  // read expression.
+      return;
+    case kVariableDeclaration:
+      SkipVariableDeclaration();
+      return;
+    case kFunctionDeclaration:
+      // TODO(jensj)
+      UNIMPLEMENTED();
+      return;
+    default:
+      UNREACHABLE();
+  }
+}
 
 CanonicalName* StreamingFlowGraphBuilder::GetCanonicalName(intptr_t index) {
   if (index == 0) return NULL;
   --index;
 
   if (canonical_names_ != NULL && canonical_names_entries_read_ > index) {
     return canonical_names_[index];
   }
 
   intptr_t saved_offset = ReaderOffset();
   if (canonical_names_ == NULL) {
     // Find offset from where to read canonical names table.
 
     // Skip the magic number.
     reader_->set_offset(4);
 
     // Skip the string table.  The last offset is the end offset of the last
     // string which gives the length of the string data.
-    intptr_t list_length = ReadListLength();
+    intptr_t list_length = ReadListLength();  // read list length.
     intptr_t end_offset = 0;
     for (intptr_t i = 0; i < list_length; ++i) {
-      end_offset = ReadUInt();
+      end_offset = ReadUInt();  // read ith offset.
     }
     SkipBytes(end_offset);
 
     // There is another string table for the source URIs.  Skip it as well.
-    list_length = ReadListLength();
+    list_length = ReadListLength();  // read list length.
     end_offset = 0;
     for (intptr_t i = 0; i < list_length; ++i) {
-      end_offset = ReadUInt();
+      end_offset = ReadUInt();  // read ith offset.
     }
     SkipBytes(end_offset);
 
     // Source code table
     for (intptr_t i = 0; i < list_length; ++i) {
       // Source code
-      intptr_t bytes = ReadUInt();
-      SkipBytes(bytes);
+      intptr_t bytes = ReadUInt();  // read ith byte length.
+      SkipBytes(bytes);             // read ith souce code package.
 
       // Line starts table
-      intptr_t line_count = ReadUInt();
+      intptr_t line_count = ReadUInt();  // read list length.
       for (intptr_t j = 0; j < line_count; ++j) {
-        ReadUInt();
+        ReadUInt();  // read jth line start.
       }
     }
 
     // Now at canonical names table.
-    canonical_names_size_ = ReadUInt();
+    canonical_names_size_ = ReadUInt();  // read number of canonical names.
     canonical_names_ = new CanonicalName*[canonical_names_size_];
     canonical_names_next_offset_ = ReaderOffset();
   }
 
   SetOffset(canonical_names_next_offset_);
   for (; canonical_names_entries_read_ <= index;
        ++canonical_names_entries_read_) {
-    intptr_t biased_parent_index = ReadUInt();
+    intptr_t biased_parent_index = ReadUInt();  // read parent index.
     CanonicalName* parent;
     if (biased_parent_index != 0) {
       parent = canonical_names_[biased_parent_index - 1];
     } else {
       if (canonical_names_entries_read_ == 0) {
         parent = CanonicalName::NewRoot();
       } else {
         parent = canonical_names_[0]->parent();
       }
     }
     ASSERT(parent != NULL);
-    intptr_t name_index = ReadUInt();
+    intptr_t name_index = ReadUInt();  // read name index.
     CanonicalName* canonical_name = parent->AddChild(name_index);
     canonical_names_[canonical_names_entries_read_] = canonical_name;
   }
 
   canonical_names_next_offset_ = ReaderOffset();
 
   SetOffset(saved_offset);
   return canonical_names_[index];
 }
 
+intptr_t StreamingFlowGraphBuilder::ReadNameAsStringIndex() {
+  intptr_t name_index = ReadUInt();  // read name index.
+  if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
+    ReadUInt();  // read library index.
+  }
+  return name_index;
+}
+
+const dart::String& StreamingFlowGraphBuilder::ReadNameAsMethodName() {
+  intptr_t name_index = ReadUInt();  // read name index.
+  if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
+    CanonicalName* library_reference =
+        GetCanonicalName(ReadUInt());  // read library index.
+    return H.DartMethodName(library_reference, name_index);
+  } else {
+    return H.DartMethodName(NULL, name_index);
+  }
+}
+
+const dart::String& StreamingFlowGraphBuilder::ReadNameAsSetterName() {
+  intptr_t name_index = ReadUInt();  // read name index.
+  if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
+    CanonicalName* library_reference =
+        GetCanonicalName(ReadUInt());  // read library index.
+    return H.DartSetterName(library_reference, name_index);
+  } else {
+    return H.DartSetterName(NULL, name_index);
+  }
+}
+
+const dart::String& StreamingFlowGraphBuilder::ReadNameAsGetterName() {
+  intptr_t name_index = ReadUInt();  // read name index.
+  if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
+    CanonicalName* library_reference =
+        GetCanonicalName(ReadUInt());  // read library index.
+    return H.DartGetterName(library_reference, name_index);
+  } else {
+    return H.DartGetterName(NULL, name_index);
+  }
+}
+
+void StreamingFlowGraphBuilder::UpdateDirectDescendantPosition(
+    TokenPosition position) {
+  if (direct_descendant_position_ == TokenPosition::kLast) {
+    direct_descendant_position_ = position;
+  }
+}
+
+void StreamingFlowGraphBuilder::ResetDirectDescendantPosition() {
+  direct_descendant_position_ = TokenPosition::kLast;
+}
 
 intptr_t StreamingFlowGraphBuilder::ReaderOffset() {
   return reader_->offset();
 }
 
-
 void StreamingFlowGraphBuilder::SetOffset(intptr_t offset) {
   reader_->set_offset(offset);
 }
 
-
 void StreamingFlowGraphBuilder::SkipBytes(intptr_t bytes) {
   reader_->set_offset(ReaderOffset() + bytes);
 }
 
+bool StreamingFlowGraphBuilder::ReadBool() {
+  return reader_->ReadBool();
+}
+
+uint8_t StreamingFlowGraphBuilder::ReadByte() {
+  return reader_->ReadByte();
+}
 
 uint32_t StreamingFlowGraphBuilder::ReadUInt() {
   return reader_->ReadUInt();
 }
 
+uint32_t StreamingFlowGraphBuilder::PeekUInt() {
+  intptr_t offset = ReaderOffset();
+  uint32_t result = reader_->ReadUInt();
+  SetOffset(offset);
+  return result;
+}
 
 intptr_t StreamingFlowGraphBuilder::ReadListLength() {
   return reader_->ReadListLength();
 }
 
+void StreamingFlowGraphBuilder::SkipDartType() {
+  Tag tag = ReadTag();
+  switch (tag) {
+    case kInvalidType:
+    case kDynamicType:
+    case kVoidType:
+      // those contain nothing.
+      return;
+    case kInterfaceType:
+      SkipInterfaceType(false);
+      return;
+    case kSimpleInterfaceType:
+      SkipInterfaceType(true);
+      return;
+    case kFunctionType:
+      SkipFunctionType(false);
+      return;
+    case kSimpleFunctionType:
+      SkipFunctionType(true);
+      return;
+    case kTypeParameterType:
+      ReadUInt();  // read index for parameter.
+      ReadUInt();  // binary offset.
+      return;
+    default:
+      UNREACHABLE();
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipOptionalDartType() {
+  Tag tag = ReadTag();  // read tag.
+  if (tag == kNothing) {
+    return;
+  }
+  ASSERT(tag == kSomething);
+
+  SkipDartType();  // read type.
+}
+
+void StreamingFlowGraphBuilder::SkipInterfaceType(bool simple) {
+  ReadUInt();  // read klass_name.
+  if (!simple) {
+    intptr_t length = ReadListLength();  // read number of types.
+    for (intptr_t i = 0; i < length; ++i) {
+      SkipDartType();  // skip the ith type.
+    }
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipFunctionType(bool simple) {
+  if (!simple) {
+    intptr_t list_length =
+        ReadListLength();  // read type_parameters list length.
+    for (int i = 0; i < list_length; ++i) {
+      ReadUInt();  // read string index (name).

[jensj, 2017/05/04 10:13:05]

I've added the missing "SkipDartType();" locally...

+    }
+    ReadUInt();  // read required parameter count.
+    ReadUInt();  // read total parameter count.
+  }
+
+  const intptr_t positional_count =
+      ReadListLength();  // read positional_parameters list length.
+  for (intptr_t i = 0; i < positional_count; ++i) {
+    SkipDartType();  // read ith positional parameter.
+  }
+
+  if (!simple) {
+    const intptr_t named_count =
+        ReadListLength();  // read named_parameters list length.
+    for (intptr_t i = 0; i < named_count; ++i) {
+      ReadUInt();      // read string reference (i.e. named_parameters[i].name).
+      SkipDartType();  // read named_parameters[i].type.
+    }
+  }
+
+  SkipDartType();  // read return type.
+}
+
+void StreamingFlowGraphBuilder::SkipExpression() {
+  uint8_t payload = 0;
+  Tag tag = ReadTag(&payload);
+  switch (tag) {
+    case kInvalidExpression:
+      return;
+    case kVariableGet:
+      ReadPosition();          // read position.
+      ReadUInt();              // read kernel position.
+      ReadUInt();              // read relative variable index.
+      SkipOptionalDartType();  // read promoted type.
+      return;
+    case kSpecializedVariableGet:
+      ReadPosition();  // read position.
+      ReadUInt();      // read kernel position.
+      return;
+    case kVariableSet:
+      ReadPosition();    // read position.
+      ReadUInt();        // read kernel position.
+      ReadUInt();        // read relative variable index.
+      SkipExpression();  // read expression.
+      return;
+    case kSpecializedVariableSet:
+      ReadPosition();    // read position.
+      ReadUInt();        // read kernel position.
+      SkipExpression();  // read expression.
+      return;
+    case kPropertyGet:
+      ReadPosition();    // read position.
+      SkipExpression();  // read receiver.
+      SkipName();        // read name.
+      ReadUInt();        // Read unused "interface_target_reference".
+      return;
+    case kPropertySet:
+      ReadPosition();    // read position.
+      SkipExpression();  // read receiver.
+      SkipName();        // read name.
+      SkipExpression();  // read value.
+      ReadUInt();        // read unused "interface_target_reference".
+      return;
+    case kDirectPropertyGet:
+      ReadPosition();    // read position.
+      SkipExpression();  // read receiver.
+      ReadUInt();        // read target_reference.
+      return;
+    case kDirectPropertySet:
+      ReadPosition();    // read position.
+      SkipExpression();  // read receiver.
+      ReadUInt();        // read target_reference.
+      SkipExpression();  // read value·
+      return;
+    case kStaticGet:
+      ReadPosition();  // read position.
+      ReadUInt();      // read target_reference.
+      return;
+    case kStaticSet:
+      ReadPosition();    // read position.
+      ReadUInt();        // read target_reference.
+      SkipExpression();  // read expression.
+      return;
+    case kMethodInvocation:
+      ReadPosition();    // read position.
+      SkipExpression();  // read receiver.
+      SkipName();        // read name.
+      SkipArguments();   // read arguments.
+      ReadUInt();        // read unused "interface_target_reference".
+      return;
+    case kDirectMethodInvocation:
+      SkipExpression();  // read receiver.
+      ReadUInt();        // read target_reference.
+      SkipArguments();   // read arguments.
+      return;
+    case kStaticInvocation:
+    case kConstStaticInvocation:
+      ReadPosition();   // read position.
+      ReadUInt();       // read procedure_reference.
+      SkipArguments();  // read arguments.
+      return;
+    case kConstructorInvocation:
+    case kConstConstructorInvocation:
+      ReadPosition();   // read position.
+      ReadUInt();       // read target_reference.
+      SkipArguments();  // read arguments.
+      return;
+    case kNot:
+      SkipExpression();  // read expression.
+      return;
+    case kLogicalExpression:
+      SkipExpression();  // read left.
+      SkipBytes(1);      // read operator.
+      SkipExpression();  // read right.
+      return;
+    case kConditionalExpression:
+      SkipExpression();        // read condition.
+      SkipExpression();        // read then.
+      SkipExpression();        // read ohterwise.
+      SkipOptionalDartType();  // read unused static type.
+      return;
+    case kStringConcatenation: {
+      ReadPosition();                           // read position.
+      intptr_t list_length = ReadListLength();  // read list length.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipExpression();  // read ith expression.
+      }
+      return;
+    }
+    case kIsExpression:
+      ReadPosition();    // read position.
+      SkipExpression();  // read operand.
+      SkipDartType();    // read type.
+      return;
+    case kAsExpression:
+      ReadPosition();    // read position.
+      SkipExpression();  // read operand.
+      SkipDartType();    // read type.
+      return;
+    case kSymbolLiteral:
+      ReadUInt();  // read index into string table.
+      return;
+    case kTypeLiteral:
+      SkipDartType();  // read type.
+      return;
+    case kThisExpression:
+      return;
+    case kRethrow:
+      ReadPosition();  // read position.
+      return;
+    case kThrow:
+      ReadPosition();    // read position.
+      SkipExpression();  // read expression.
+      return;
+    case kListLiteral:
+    case kConstListLiteral: {
+      ReadPosition();                           // read position.
+      SkipDartType();                           // read type.
+      intptr_t list_length = ReadListLength();  // read list length.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipExpression();  // read ith expression.
+      }
+      return;
+    }
+    case kMapLiteral:
+    case kConstMapLiteral: {
+      ReadPosition();                           // read position.
+      SkipDartType();                           // read key type.
+      SkipDartType();                           // read value type.
+      intptr_t list_length = ReadListLength();  // read list length.
+      for (intptr_t i = 0; i < list_length; ++i) {
+        SkipExpression();  // read ith key.
+        SkipExpression();  // read ith value.
+      }
+      return;
+    }
+    case kFunctionExpression:
+      // TODO(jensj)
+      UNIMPLEMENTED();
+      return;
+    case kLet:
+      SkipVariableDeclaration();  // read variable declaration.
+      SkipExpression();           // read expression.
+      return;
+    case kBigIntLiteral:
+      ReadUInt();  // read string reference.
+      return;
+    case kStringLiteral:
+      ReadUInt();  // read string reference.
+      return;
+    case kSpecialIntLiteral:
+      return;
+    case kNegativeIntLiteral:
+      ReadUInt();  // read value.
+      return;
+    case kPositiveIntLiteral:
+      ReadUInt();  // read value.
+      return;
+    case kDoubleLiteral:
+      ReadUInt();  // read index into string table.
+      return;
+    case kTrueLiteral:
+      return;
+    case kFalseLiteral:
+      return;
+    case kNullLiteral:
+      return;
+    default:
+      UNREACHABLE();
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipName() {
+  intptr_t name_index = ReadUInt();  // read name index.
+  if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
+    ReadUInt();  // read library index.
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipArguments() {
+  ReadUInt();  // read argument count.
+
+  // List of types.
+  intptr_t list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    SkipDartType();  // read ith type.
+  }
+
+  // List of positional.
+  list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    SkipExpression();  // read ith expression.
+  }
+
+  // List of named.
+  list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    ReadUInt();        // read ith name index.
+    SkipExpression();  // read ith expression.
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipVariableDeclaration() {
+  ReadPosition();       // read position.
+  ReadPosition();       // read equals position.
+  ReadFlags();          // read flags.
+  ReadUInt();           // read name index.
+  SkipDartType();       // read type.
+  Tag tag = ReadTag();  // read (first part of) initializer.
+  if (tag == kSomething) {
+    SkipExpression();  // read (actual) initializer.
+  }
+}
 
 TokenPosition StreamingFlowGraphBuilder::ReadPosition(bool record) {
   return reader_->ReadPosition(record);
 }
 
-
 Tag StreamingFlowGraphBuilder::ReadTag(uint8_t* payload) {
   return reader_->ReadTag(payload);
 }
 
+Tag StreamingFlowGraphBuilder::PeekTag(uint8_t* payload) {
+  return reader_->PeekTag(payload);
+}
+
+word StreamingFlowGraphBuilder::ReadFlags() {
+  return reader_->ReadFlags();
+}
+
+void StreamingFlowGraphBuilder::loop_depth_inc() {
+  ++flow_graph_builder_->loop_depth_;
+}
+
+void StreamingFlowGraphBuilder::loop_depth_dec() {
+  --flow_graph_builder_->loop_depth_;
+}
+
+intptr_t StreamingFlowGraphBuilder::for_in_depth() {
+  return flow_graph_builder_->for_in_depth_;
+}
+
+void StreamingFlowGraphBuilder::for_in_depth_inc() {
+  ++flow_graph_builder_->for_in_depth_;
+}
+
+void StreamingFlowGraphBuilder::for_in_depth_dec() {
+  --flow_graph_builder_->for_in_depth_;
+}
+
+void StreamingFlowGraphBuilder::catch_depth_inc() {
+  ++flow_graph_builder_->catch_depth_;
+}
+
+void StreamingFlowGraphBuilder::catch_depth_dec() {
+  --flow_graph_builder_->catch_depth_;
+}
+
+void StreamingFlowGraphBuilder::try_depth_inc() {
+  ++flow_graph_builder_->try_depth_;
+}
+
+void StreamingFlowGraphBuilder::try_depth_dec() {
+  --flow_graph_builder_->try_depth_;
+}
+
+intptr_t StreamingFlowGraphBuilder::CurrentTryIndex() {
+  return flow_graph_builder_->CurrentTryIndex();
+}
+
+intptr_t StreamingFlowGraphBuilder::AllocateTryIndex() {
+  return flow_graph_builder_->AllocateTryIndex();
+}
+
+LocalVariable* StreamingFlowGraphBuilder::CurrentException() {
+  return flow_graph_builder_->CurrentException();
+}
+
+LocalVariable* StreamingFlowGraphBuilder::CurrentStackTrace() {
+  return flow_graph_builder_->CurrentStackTrace();
+}
 
 CatchBlock* StreamingFlowGraphBuilder::catch_block() {
   return flow_graph_builder_->catch_block_;
 }
 
+ActiveClass* StreamingFlowGraphBuilder::active_class() {
+  return &flow_graph_builder_->active_class_;
+}
 
 ScopeBuildingResult* StreamingFlowGraphBuilder::scopes() {
   return flow_graph_builder_->scopes_;
 }
 
-
 ParsedFunction* StreamingFlowGraphBuilder::parsed_function() {
   return flow_graph_builder_->parsed_function_;
 }
 
+TryFinallyBlock* StreamingFlowGraphBuilder::try_finally_block() {
+  return flow_graph_builder_->try_finally_block_;
+}
+
+SwitchBlock* StreamingFlowGraphBuilder::switch_block() {
+  return flow_graph_builder_->switch_block_;
+}
+
+BreakableBlock* StreamingFlowGraphBuilder::breakable_block() {
+  return flow_graph_builder_->breakable_block_;
+}
+
+GrowableArray<YieldContinuation>&
+StreamingFlowGraphBuilder::yield_continuations() {
+  return flow_graph_builder_->yield_continuations_;
+}
+
+Value* StreamingFlowGraphBuilder::stack() {
+  return flow_graph_builder_->stack_;
+}
+
+Value* StreamingFlowGraphBuilder::Pop() {
+  return flow_graph_builder_->Pop();
+}
+
+Tag StreamingFlowGraphBuilder::PeekArgumentsFirstPositionalTag() {
+  intptr_t offset = ReaderOffset();
+  ReadUInt();  // read number of arguments.
+
+  // List of types.
+  intptr_t list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    SkipDartType();  // read ith type.
+  }
+
+  // List of positional.
+  list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    Tag tag = ReadTag();  // read first tag.
+    SetOffset(offset);    // reset offset so this was a peek.
+    return tag;
+  }
+
+  UNREACHABLE();
+  return kNothing;
+}
+
+const TypeArguments& StreamingFlowGraphBuilder::PeekArgumentsInstantiatedType(
+    const dart::Class& klass) {
+  // read parts of arguments, then go back to before doing so.
+  intptr_t offset = ReaderOffset();
+  ReadUInt();                               // read argument count.
+  intptr_t list_length = ReadListLength();  // read types list length.
+  const TypeArguments& type_arguments =
+      T.BuildInstantiatedTypeArguments(klass, list_length);  // read types.
+  SetOffset(offset);
+  return type_arguments;
+}
+
+intptr_t StreamingFlowGraphBuilder::PeekArgumentsCount() {
+  return PeekUInt();
+}
+
+intptr_t StreamingFlowGraphBuilder::PeekArgumentsTypeCount() {
+  intptr_t offset = ReaderOffset();
+  ReadUInt();                               // read arguments count.
+  intptr_t types_count = ReadListLength();  // read length of types list.
+  SetOffset(offset);
+  return types_count;
+}
+
+void StreamingFlowGraphBuilder::SkipArgumentsBeforeActualArguments() {
+  ReadUInt();  // read arguments count.
+  intptr_t types_count = ReadListLength();
+  for (intptr_t i = 0; i < types_count; ++i) {
+    SkipDartType();  // read ith type.
+  }
+}
+
+LocalVariable* StreamingFlowGraphBuilder::LookupVariable(
+    intptr_t kernel_offset) {
+  return flow_graph_builder_->LookupVariable(kernel_offset);
+}
+
+LocalVariable* StreamingFlowGraphBuilder::MakeTemporary() {
+  return flow_graph_builder_->MakeTemporary();
+}
+
+Token::Kind StreamingFlowGraphBuilder::MethodKind(const dart::String& name) {
+  return flow_graph_builder_->MethodKind(name);
+}
+
+dart::RawFunction* StreamingFlowGraphBuilder::LookupMethodByMember(
+    CanonicalName* target,
+    const dart::String& method_name) {
+  return flow_graph_builder_->LookupMethodByMember(target, method_name);
+}
+
+bool StreamingFlowGraphBuilder::NeedsDebugStepCheck(const Function& function,
+                                                    TokenPosition position) {
+  return flow_graph_builder_->NeedsDebugStepCheck(function, position);
+}
+
+bool StreamingFlowGraphBuilder::NeedsDebugStepCheck(Value* value,
+                                                    TokenPosition position) {
+  return flow_graph_builder_->NeedsDebugStepCheck(value, position);
+}
+
+void StreamingFlowGraphBuilder::InlineBailout(const char* reason) {
+  flow_graph_builder_->InlineBailout(reason);
+}
 
 Fragment StreamingFlowGraphBuilder::DebugStepCheck(TokenPosition position) {
   return flow_graph_builder_->DebugStepCheck(position);
 }
 
-
 Fragment StreamingFlowGraphBuilder::LoadLocal(LocalVariable* variable) {
   return flow_graph_builder_->LoadLocal(variable);
 }
 
+Fragment StreamingFlowGraphBuilder::Return(TokenPosition position) {
+  return flow_graph_builder_->Return(position);
+}
 
 Fragment StreamingFlowGraphBuilder::PushArgument() {
   return flow_graph_builder_->PushArgument();
 }
 
+Fragment StreamingFlowGraphBuilder::EvaluateAssertion() {
+  return flow_graph_builder_->EvaluateAssertion();
+}
 
 Fragment StreamingFlowGraphBuilder::RethrowException(TokenPosition position,
                                                      int catch_try_index) {
   return flow_graph_builder_->RethrowException(position, catch_try_index);
 }
 
-
 Fragment StreamingFlowGraphBuilder::ThrowNoSuchMethodError() {
   return flow_graph_builder_->ThrowNoSuchMethodError();
 }
 
-
 Fragment StreamingFlowGraphBuilder::Constant(const Object& value) {
   return flow_graph_builder_->Constant(value);
 }
 
-
 Fragment StreamingFlowGraphBuilder::IntConstant(int64_t value) {
   return flow_graph_builder_->IntConstant(value);
 }
 
-
 Fragment StreamingFlowGraphBuilder::LoadStaticField() {
   return flow_graph_builder_->LoadStaticField();
 }
 
-
 Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
                                                const Function& target,
                                                intptr_t argument_count) {
   return flow_graph_builder_->StaticCall(position, target, argument_count);
 }
 
+Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
+                                               const Function& target,
+                                               intptr_t argument_count,
+                                               const Array& argument_names) {
+  return flow_graph_builder_->StaticCall(position, target, argument_count,
+                                         argument_names);
+}
+
+Fragment StreamingFlowGraphBuilder::InstanceCall(TokenPosition position,
+                                                 const dart::String& name,
+                                                 Token::Kind kind,
+                                                 intptr_t argument_count,
+                                                 intptr_t num_args_checked) {
+  return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
+                                           num_args_checked);
+}
+
+Fragment StreamingFlowGraphBuilder::ThrowException(TokenPosition position) {
+  return flow_graph_builder_->ThrowException(position);
+}
+
+Fragment StreamingFlowGraphBuilder::BooleanNegate() {
+  return flow_graph_builder_->BooleanNegate();
+}
+
+Fragment StreamingFlowGraphBuilder::TranslateInstantiatedTypeArguments(
+    const TypeArguments& type_arguments) {
+  return flow_graph_builder_->TranslateInstantiatedTypeArguments(
+      type_arguments);
+}
+
+Fragment StreamingFlowGraphBuilder::StrictCompare(Token::Kind kind,
+                                                  bool number_check) {
+  return flow_graph_builder_->StrictCompare(kind, number_check);
+}
+
+Fragment StreamingFlowGraphBuilder::AllocateObject(const dart::Class& klass,
+                                                   intptr_t argument_count) {
+  return flow_graph_builder_->AllocateObject(klass, argument_count);
+}
+
+Fragment StreamingFlowGraphBuilder::InstanceCall(TokenPosition position,
+                                                 const dart::String& name,
+                                                 Token::Kind kind,
+                                                 intptr_t argument_count,
+                                                 const Array& argument_names,
+                                                 intptr_t num_args_checked) {
+  return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
+                                           argument_names, num_args_checked);
+}
+
+Fragment StreamingFlowGraphBuilder::StoreLocal(TokenPosition position,
+                                               LocalVariable* variable) {
+  return flow_graph_builder_->StoreLocal(position, variable);
+}
+
+Fragment StreamingFlowGraphBuilder::StoreStaticField(TokenPosition position,
+                                                     const dart::Field& field) {
+  return flow_graph_builder_->StoreStaticField(position, field);
+}
+
+Fragment StreamingFlowGraphBuilder::StringInterpolate(TokenPosition position) {
+  return flow_graph_builder_->StringInterpolate(position);
+}
+
+Fragment StreamingFlowGraphBuilder::StringInterpolateSingle(
+    TokenPosition position) {
+  return flow_graph_builder_->StringInterpolateSingle(position);
+}
+
+Fragment StreamingFlowGraphBuilder::ThrowTypeError() {
+  return flow_graph_builder_->ThrowTypeError();
+}
+
+Fragment StreamingFlowGraphBuilder::LoadInstantiatorTypeArguments() {
+  return flow_graph_builder_->LoadInstantiatorTypeArguments();
+}
+
+Fragment StreamingFlowGraphBuilder::LoadFunctionTypeArguments() {
+  return flow_graph_builder_->LoadFunctionTypeArguments();
+}
+
+Fragment StreamingFlowGraphBuilder::InstantiateType(const AbstractType& type) {
+  return flow_graph_builder_->InstantiateType(type);
+}
+
+Fragment StreamingFlowGraphBuilder::CreateArray() {
+  return flow_graph_builder_->CreateArray();
+}
+
+Fragment StreamingFlowGraphBuilder::StoreIndexed(intptr_t class_id) {
+  return flow_graph_builder_->StoreIndexed(class_id);
+}
+
+Fragment StreamingFlowGraphBuilder::CheckStackOverflow() {
+  return flow_graph_builder_->CheckStackOverflow();
+}
+
+Fragment StreamingFlowGraphBuilder::CloneContext() {
+  return flow_graph_builder_->CloneContext();
+}
+
+Fragment StreamingFlowGraphBuilder::TranslateFinallyFinalizers(
+    TryFinallyBlock* outer_finally,
+    intptr_t target_context_depth) {
+  // TODO(jensj): TranslateFinallyFinalizers can move the readers offset.
+  // For now we'll save it and restore it afterwards.
+  intptr_t offset = ReaderOffset();
+  Fragment result = flow_graph_builder_->TranslateFinallyFinalizers(
+      outer_finally, target_context_depth);
+  SetOffset(offset);
+  return result;
+}
+
+Fragment StreamingFlowGraphBuilder::BranchIfTrue(
+    TargetEntryInstr** then_entry,
+    TargetEntryInstr** otherwise_entry,
+    bool negate) {
+  return flow_graph_builder_->BranchIfTrue(then_entry, otherwise_entry, negate);
+}
+
+Fragment StreamingFlowGraphBuilder::BranchIfEqual(
+    TargetEntryInstr** then_entry,
+    TargetEntryInstr** otherwise_entry,
+    bool negate) {
+  return flow_graph_builder_->BranchIfEqual(then_entry, otherwise_entry,
+                                            negate);
+}
+
+Fragment StreamingFlowGraphBuilder::BranchIfNull(
+    TargetEntryInstr** then_entry,
+    TargetEntryInstr** otherwise_entry,
+    bool negate) {
+  return flow_graph_builder_->BranchIfNull(then_entry, otherwise_entry, negate);
+}
+
+Fragment StreamingFlowGraphBuilder::CatchBlockEntry(const Array& handler_types,
+                                                    intptr_t handler_index,
+                                                    bool needs_stacktrace) {
+  return flow_graph_builder_->CatchBlockEntry(handler_types, handler_index,
+                                              needs_stacktrace);
+}
+
+Fragment StreamingFlowGraphBuilder::TryCatch(int try_handler_index) {
+  return flow_graph_builder_->TryCatch(try_handler_index);
+}
+
+Fragment StreamingFlowGraphBuilder::Drop() {
+  return flow_graph_builder_->Drop();
+}
+
+Fragment StreamingFlowGraphBuilder::NullConstant() {
+  return flow_graph_builder_->NullConstant();
+}
+
+JoinEntryInstr* StreamingFlowGraphBuilder::BuildJoinEntry() {
+  return flow_graph_builder_->BuildJoinEntry();
+}
+
+JoinEntryInstr* StreamingFlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
+  return flow_graph_builder_->BuildJoinEntry(try_index);
+}
+
+Fragment StreamingFlowGraphBuilder::Goto(JoinEntryInstr* destination) {
+  return flow_graph_builder_->Goto(destination);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildImplicitClosureCreation(
+    const Function& target) {
+  return flow_graph_builder_->BuildImplicitClosureCreation(target);
+}
+
+Fragment StreamingFlowGraphBuilder::CheckBooleanInCheckedMode() {
+  return flow_graph_builder_->CheckBooleanInCheckedMode();
+}
+
+Fragment StreamingFlowGraphBuilder::CheckAssignableInCheckedMode(
+    const dart::AbstractType& dst_type,
+    const dart::String& dst_name) {
+  return flow_graph_builder_->CheckAssignableInCheckedMode(dst_type, dst_name);
+}
+
+Fragment StreamingFlowGraphBuilder::CheckVariableTypeInCheckedMode(
+    intptr_t variable_kernel_position) {
+  if (I->type_checks()) {
+    LocalVariable* variable = LookupVariable(variable_kernel_position);
+    return flow_graph_builder_->CheckVariableTypeInCheckedMode(
+        variable->type(), variable->name());
+  }
+  return Fragment();
+}
+
+Fragment StreamingFlowGraphBuilder::CheckVariableTypeInCheckedMode(
+    const AbstractType& dst_type,
+    const dart::String& name_symbol) {
+  return flow_graph_builder_->CheckVariableTypeInCheckedMode(dst_type,
+                                                             name_symbol);
+}
+
+Fragment StreamingFlowGraphBuilder::EnterScope(intptr_t kernel_offset,
+                                               bool* new_context) {
+  return flow_graph_builder_->EnterScope(kernel_offset, new_context);
+}
+
+Fragment StreamingFlowGraphBuilder::ExitScope(intptr_t kernel_offset) {
+  return flow_graph_builder_->ExitScope(kernel_offset);
+}
+
+Fragment StreamingFlowGraphBuilder::TranslateCondition(bool* negate) {
+  *negate = PeekTag() == kNot;
+  if (*negate) {
+    SkipBytes(1);  // Skip Not tag, thus go directly to the inner expression.
+  }
+  Fragment instructions = BuildExpression();  // read expression.
+  instructions += CheckBooleanInCheckedMode();
+  return instructions;
+}
+
+const TypeArguments& StreamingFlowGraphBuilder::BuildTypeArguments() {
+  ReadUInt();                                // read arguments count.
+  intptr_t types_count = ReadListLength();   // read type count.
+  return T.BuildTypeArguments(types_count);  // read types.
+}
+
+Fragment StreamingFlowGraphBuilder::BuildArguments(Array* argument_names,
+                                                   intptr_t* argument_count,
+                                                   bool skip_push_arguments,
+                                                   bool do_drop) {
+  intptr_t dummy;
+  if (argument_count == NULL) argument_count = &dummy;
+  *argument_count = ReadUInt();  // read arguments count.
+
+  // List of types.
+  intptr_t list_length = ReadListLength();  // read type count.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    SkipDartType();  // read ith type.
+  }
+
+  return BuildArgumentsFromActualArguments(argument_names, skip_push_arguments,
+                                           do_drop);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildArgumentsFromActualArguments(
+    Array* argument_names,
+    bool skip_push_arguments,
+    bool do_drop) {
+  Fragment instructions;
+
+  // List of positional.
+  intptr_t list_length = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    instructions += BuildExpression();  // read ith expression.
+    if (!skip_push_arguments) instructions += PushArgument();
+    if (do_drop) instructions += Drop();
+  }
+
+  // List of named.
+  list_length = ReadListLength();  // read list length.
+  if (argument_names != NULL && list_length > 0) {
+    *argument_names ^= Array::New(list_length, Heap::kOld);
+  }
+  for (intptr_t i = 0; i < list_length; ++i) {
+    dart::String& name = H.DartSymbol(ReadUInt());  // read ith name index.
+    instructions += BuildExpression();              // read ith expression.
+    if (!skip_push_arguments) instructions += PushArgument();
+    if (do_drop) instructions += Drop();
+    if (argument_names != NULL) {
+      argument_names->SetAt(i, name);
+    }
+  }
+
+  return instructions;
+}
 
 Fragment StreamingFlowGraphBuilder::BuildInvalidExpression() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);

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

How about an optional output parameter defaulting to NULL that you set if it's
non-NULL:

Fragment StreamingFlowGraphBuilder::BuildInvalidExpression(TokenPosition*
position) {
  (position != NULL) ? *position = TokenPosition::kNoSource;
  ...
}

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

Done.

+
   // The frontend will take care of emitting normal errors (like
   // [NoSuchMethodError]s) and only emit [InvalidExpression]s in very special
   // situations (e.g. an invalid annotation).
   return ThrowNoSuchMethodError();
 }
 
+Fragment StreamingFlowGraphBuilder::BuildVariableGet() {
+  UpdateDirectDescendantPosition(ReadPosition());  // read position.
+  intptr_t variable_kernel_position = ReadUInt();  // read kernel position.
+  ReadUInt();              // read relative variable index.
+  SkipOptionalDartType();  // read promoted type.
+
+  return LoadLocal(LookupVariable(variable_kernel_position));
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVariableGet(uint8_t payload) {
+  UpdateDirectDescendantPosition(ReadPosition());  // read position.
+  intptr_t variable_kernel_position = ReadUInt();  // read kernel position.
+  return LoadLocal(LookupVariable(variable_kernel_position));
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVariableSet() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t variable_kernel_position = ReadUInt();  // read kernel position.
+  ReadUInt();                                 // read relative variable index.
+  Fragment instructions = BuildExpression();  // read expression.
+
+  if (NeedsDebugStepCheck(stack(), position)) {
+    instructions = DebugStepCheck(position) + instructions;
+  }
+  instructions += CheckVariableTypeInCheckedMode(variable_kernel_position);
+  instructions +=
+      StoreLocal(position, LookupVariable(variable_kernel_position));
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVariableSet(uint8_t payload) {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t variable_kernel_position = ReadUInt();  // read kernel position.
+  Fragment instructions = BuildExpression();       // read expression.
+
+  if (NeedsDebugStepCheck(stack(), position)) {
+    instructions = DebugStepCheck(position) + instructions;
+  }
+  instructions += CheckVariableTypeInCheckedMode(variable_kernel_position);
+  instructions +=
+      StoreLocal(position, LookupVariable(variable_kernel_position));
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildPropertyGet() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions = BuildExpression();  // read receiver.
+  instructions += PushArgument();
+
+  const dart::String& getter_name = ReadNameAsGetterName();  // read name.
+  ReadUInt();  // Read unused "interface_target_reference".
+
+  return instructions + InstanceCall(position, getter_name, Token::kGET, 1);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildPropertySet() {
+  Fragment instructions(NullConstant());
+  LocalVariable* variable = MakeTemporary();
+
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  instructions += BuildExpression();  // read receiver.
+  instructions += PushArgument();
+
+  const dart::String& setter_name = ReadNameAsSetterName();  // read name.
+
+  instructions += BuildExpression();  // read value.
+  instructions += StoreLocal(TokenPosition::kNoSource, variable);
+  instructions += PushArgument();
+
+  ReadUInt();  // read unused "interface_target_reference".
+
+  instructions += InstanceCall(position, setter_name, Token::kSET, 2);
+  return instructions + Drop();
+}
+
+Fragment StreamingFlowGraphBuilder::BuildDirectPropertyGet() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions = BuildExpression();  // read receiver.
+  CanonicalName* kernel_name =
+      GetCanonicalName(ReadUInt());  // read target_reference.
+
+  Function& target = Function::ZoneHandle(Z);
+  if (H.IsProcedure(kernel_name)) {
+    if (H.IsGetter(kernel_name)) {
+      target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
+    } else {
+      // Undo stack change for the BuildExpression.
+      Pop();
+
+      target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
+      target = target.ImplicitClosureFunction();
+      ASSERT(!target.IsNull());
+      return BuildImplicitClosureCreation(target);
+    }
+  } else {
+    ASSERT(H.IsField(kernel_name));
+    const dart::String& getter_name = H.DartGetterName(kernel_name);
+    target = LookupMethodByMember(kernel_name, getter_name);
+    ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
+  }
+
+  instructions += PushArgument();
+  return instructions + StaticCall(position, target, 1);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildDirectPropertySet() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions(NullConstant());
+  LocalVariable* value = MakeTemporary();
+
+  instructions += BuildExpression();  // read receiver.
+  instructions += PushArgument();
+
+  CanonicalName* target_reference =
+      GetCanonicalName(ReadUInt());  // read target_reference.
+  const dart::String& method_name = H.DartSetterName(target_reference);
+  const Function& target = Function::ZoneHandle(
+      Z, LookupMethodByMember(target_reference, method_name));
+  ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
+
+  instructions += BuildExpression();  // read value.
+  instructions += StoreLocal(TokenPosition::kNoSource, value);
+  instructions += PushArgument();
+
+  instructions += StaticCall(position, target, 2);
+
+  return instructions + Drop();
+}
 
 Fragment StreamingFlowGraphBuilder::BuildStaticGet() {
-  intptr_t saved_offset = ReaderOffset() - 1;  // Include the tag.
-  TokenPosition position = ReadPosition();
-  int canonical_name_index = ReadUInt();
+  intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t canonical_name_index = ReadUInt();  // read target_reference.
   CanonicalName* target = GetCanonicalName(canonical_name_index);
 
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     if (field.is_const()) {
-      SetOffset(saved_offset);  // EvaluateExpression needs the tag.
-      return Constant(constant_evaluator_.EvaluateExpression());
+      return Constant(constant_evaluator_.EvaluateExpression(offset));
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
       const dart::String& getter_name = H.DartGetterName(target);
       const Function& getter =
           Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
       if (getter.IsNull() || !field.has_initializer()) {
         Fragment instructions = Constant(field);
         return instructions + LoadStaticField();
       } else {
         return StaticCall(position, getter, 0);
       }
     }
   } else {
     const Function& function =
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
     if (H.IsGetter(target)) {
       return StaticCall(position, function, 0);
     } else if (H.IsMethod(target)) {
-      SetOffset(saved_offset);  // EvaluateExpression needs the tag.
-      return Constant(constant_evaluator_.EvaluateExpression());
+      return Constant(constant_evaluator_.EvaluateExpression(offset));
     } else {
       UNIMPLEMENTED();
     }
   }
 
   return Fragment();
 }
 
+Fragment StreamingFlowGraphBuilder::BuildStaticSet() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t canonical_name_index = ReadUInt();  // read target_reference.
+  CanonicalName* target = GetCanonicalName(canonical_name_index);
+
+  if (H.IsField(target)) {
+    const dart::Field& field =
+        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
+    const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
+    Fragment instructions = BuildExpression();  // read expression.
+    if (NeedsDebugStepCheck(stack(), position)) {
+      instructions = DebugStepCheck(position) + instructions;
+    }
+    instructions += CheckAssignableInCheckedMode(
+        dst_type, dart::String::ZoneHandle(Z, field.name()));
+    LocalVariable* variable = MakeTemporary();
+    instructions += LoadLocal(variable);
+    return instructions + StoreStaticField(position, field);
+  } else {
+    ASSERT(H.IsProcedure(target));
+
+    // Evaluate the expression on the right hand side.
+    Fragment instructions = BuildExpression();  // read expression.
+    LocalVariable* variable = MakeTemporary();
+
+    // Prepare argument.
+    instructions += LoadLocal(variable);
+    instructions += PushArgument();
+
+    // Invoke the setter function.
+    const Function& function =
+        Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
+    instructions += StaticCall(position, function, 1);
+
+    // Drop the unused result & leave the stored value on the stack.
+    return instructions + Drop();
+  }
+}
+
+static bool IsNumberLiteral(Tag tag) {
+  return tag == kNegativeIntLiteral || tag == kPositiveIntLiteral ||
+         tag == kSpecialIntLiteral || tag == kDoubleLiteral;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildMethodInvocation() {
+  intptr_t offset = ReaderOffset() - 1;     // Include the tag.
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Tag receiver_tag = PeekTag();  // peek tag for receiver.
+  if (IsNumberLiteral(receiver_tag)) {
+    intptr_t before_branch_offset = ReaderOffset();
+
+    SkipExpression();  // read receiver (it's just a number literal).
+
+    const dart::String& name = ReadNameAsMethodName();  // read name.
+    const Token::Kind token_kind = MethodKind(name);
+    intptr_t argument_count = PeekArgumentsCount() + 1;
+
+    if ((argument_count == 1) && (token_kind == Token::kNEGATE)) {
+      const Object& result = constant_evaluator_.EvaluateExpressionSafe(offset);
+      if (!result.IsError()) {
+        SkipArguments();  // read arguments (there are none).
+        ReadUInt();       // read unused "interface_target_reference".
+        return Constant(result);
+      }
+    } else if ((argument_count == 2) &&
+               Token::IsBinaryArithmeticOperator(token_kind) &&
+               IsNumberLiteral(PeekArgumentsFirstPositionalTag())) {
+      const Object& result = constant_evaluator_.EvaluateExpressionSafe(offset);
+      if (!result.IsError()) {
+        SkipArguments();
+        ReadUInt();  // read unused "interface_target_reference".
+        return Constant(result);
+      }
+    }
+
+    SetOffset(before_branch_offset);
+  }
+
+  Fragment instructions = BuildExpression();  // read receiver.
+
+  const dart::String& name = ReadNameAsMethodName();  // read name.
+  const Token::Kind token_kind = MethodKind(name);
+
+  // Detect comparison with null.
+  if ((token_kind == Token::kEQ || token_kind == Token::kNE) &&
+      PeekArgumentsCount() == 1 &&
+      (receiver_tag == kNullLiteral ||
+       PeekArgumentsFirstPositionalTag() == kNullLiteral)) {
+    // "==" or "!=" with null on either side.
+    instructions += BuildArguments(NULL, NULL, true);  // read arguments.
+    ReadUInt();  // read unused "interface_target_reference".
+    Token::Kind strict_cmp_kind =
+        token_kind == Token::kEQ ? Token::kEQ_STRICT : Token::kNE_STRICT;
+    return instructions +
+           StrictCompare(strict_cmp_kind, /*number_check = */ true);
+  }
+
+  instructions += PushArgument();  // push receiver as argument.
+
+  // TODO(28109) Support generic methods in the VM or reify them away.
+  Array& argument_names = Array::ZoneHandle(Z);
+  intptr_t argument_count;
+  instructions +=
+      BuildArguments(&argument_names, &argument_count);  // read arguments.
+  ++argument_count;
+
+  intptr_t num_args_checked = 1;
+  // If we have a special operation (e.g. +/-/==) we mark both arguments as
+  // to be checked.
+  if (token_kind != Token::kILLEGAL) {
+    ASSERT(argument_count <= 2);
+    num_args_checked = argument_count;
+  }
+
+  instructions += InstanceCall(position, name, token_kind, argument_count,
+                               argument_names, num_args_checked);
+  // Later optimization passes assume that result of a x.[]=(...) call is not
+  // used. We must guarantee this invariant because violation will lead to an
+  // illegal IL once we replace x.[]=(...) with a sequence that does not
+  // actually produce any value. See http://dartbug.com/29135 for more details.
+  if (name.raw() == Symbols::AssignIndexToken().raw()) {
+    instructions += Drop();
+    instructions += NullConstant();
+  }
+
+  ReadUInt();  // read unused "interface_target_reference".
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildDirectMethodInvocation() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  // TODO(28109) Support generic methods in the VM or reify them away.
+  Tag receiver_tag = PeekTag();               // peek tag for receiver.
+  Fragment instructions = BuildExpression();  // read receiver.
+
+  CanonicalName* kernel_name =
+      GetCanonicalName(ReadUInt());  // read target_reference.
+  const dart::String& method_name = H.DartProcedureName(kernel_name);
+  const Token::Kind token_kind = MethodKind(method_name);
+
+  // Detect comparison with null.
+  if ((token_kind == Token::kEQ || token_kind == Token::kNE) &&
+      PeekArgumentsCount() == 1 &&
+      (receiver_tag == kNullLiteral ||
+       PeekArgumentsFirstPositionalTag() == kNullLiteral)) {
+    // "==" or "!=" with null on either side.
+    instructions += BuildArguments(NULL, NULL, true);  // read arguments.
+    Token::Kind strict_cmp_kind =
+        token_kind == Token::kEQ ? Token::kEQ_STRICT : Token::kNE_STRICT;
+    return instructions +
+           StrictCompare(strict_cmp_kind, /*number_check = */ true);
+  }
+
+  instructions += PushArgument();  // push receiver as argument.
+
+  const Function& target =
+      Function::ZoneHandle(Z, LookupMethodByMember(kernel_name, method_name));
+
+  Array& argument_names = Array::ZoneHandle(Z);
+  intptr_t argument_count;
+  instructions +=
+      BuildArguments(&argument_names, &argument_count);  // read arguments.
+  ++argument_count;
+  return instructions + StaticCall(TokenPosition::kNoSource, target,
+                                   argument_count, argument_names);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildStaticInvocation(bool is_const) {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t canonical_name_index = ReadUInt();  // read procedure reference.
+  intptr_t argument_count = PeekArgumentsCount();
+
+  CanonicalName* procedue_reference = GetCanonicalName(canonical_name_index);
+  const Function& target = Function::ZoneHandle(
+      Z, H.LookupStaticMethodByKernelProcedure(procedue_reference));
+  const dart::Class& klass = dart::Class::ZoneHandle(Z, target.Owner());
+  if (target.IsGenerativeConstructor() || target.IsFactory()) {
+    // The VM requires a TypeArguments object as first parameter for
+    // every factory constructor.
+    ++argument_count;
+  }
+
+  Fragment instructions;
+  LocalVariable* instance_variable = NULL;
+
+  // If we cross the Kernel -> VM core library boundary, a [StaticInvocation]
+  // can appear, but the thing we're calling is not a static method, but a
+  // factory constructor.
+  // The `H.LookupStaticmethodByKernelProcedure` will potentially resolve to the
+  // forwarded constructor.
+  // In that case we'll make an instance and pass it as first argument.
+  //
+  // TODO(27590): Get rid of this after we're using core libraries compiled
+  // into Kernel.
+  if (target.IsGenerativeConstructor()) {
+    if (klass.NumTypeArguments() > 0) {
+      const TypeArguments& type_arguments =
+          PeekArgumentsInstantiatedType(klass);
+      instructions += TranslateInstantiatedTypeArguments(type_arguments);
+      instructions += PushArgument();
+      instructions += AllocateObject(klass, 1);
+    } else {
+      instructions += AllocateObject(klass, 0);
+    }
+
+    instance_variable = MakeTemporary();
+
+    instructions += LoadLocal(instance_variable);
+    instructions += PushArgument();
+  } else if (target.IsFactory()) {
+    // The VM requires currently a TypeArguments object as first parameter for
+    // every factory constructor :-/ !
+    //
+    // TODO(27590): Get rid of this after we're using core libraries compiled
+    // into Kernel.
+    const TypeArguments& type_arguments = PeekArgumentsInstantiatedType(klass);
+    instructions += TranslateInstantiatedTypeArguments(type_arguments);
+    instructions += PushArgument();
+  } else {
+    // TODO(28109) Support generic methods in the VM or reify them away.
+  }
+
+  bool special_case_identical =
+      klass.IsTopLevel() && (klass.library() == dart::Library::CoreLibrary()) &&
+      (target.name() == Symbols::Identical().raw());
+
+  Array& argument_names = Array::ZoneHandle(Z);
+  instructions += BuildArguments(&argument_names, NULL,
+                                 special_case_identical);  // read arguments.
+  ASSERT(target.AreValidArguments(argument_count, argument_names, NULL));
+
+  // Special case identical(x, y) call.
+  // TODO(27590) consider moving this into the inliner and force inline it
+  // there.
+  if (special_case_identical) {
+    ASSERT(argument_count == 2);
+    instructions += StrictCompare(Token::kEQ_STRICT, /*number_check=*/true);
+  } else {
+    instructions +=
+        StaticCall(position, target, argument_count, argument_names);
+    if (target.IsGenerativeConstructor()) {
+      // Drop the result of the constructor call and leave [instance_variable]
+      // on top-of-stack.
+      instructions += Drop();
+    }
+  }
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildConstructorInvocation(bool is_const) {
+  if (is_const) {
+    intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+    UpdateDirectDescendantPosition(ReadPosition());
+
+    SetOffset(offset);
+    SkipExpression();  // read past this ConstructorInvocation.
+    return Constant(constant_evaluator_.EvaluateConstructorInvocation(offset));
+  }
+
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  CanonicalName* kernel_name =
+      GetCanonicalName(ReadUInt());  // read target_reference.
+
+  dart::Class& klass = dart::Class::ZoneHandle(
+      Z, H.LookupClassByKernelClass(H.EnclosingName(kernel_name)));
+
+  Fragment instructions;
+
+  // Check for malbounded-ness of type.
+  if (I->type_checks()) {
+    intptr_t offset = ReaderOffset();
+
+    const TypeArguments& type_arguments = BuildTypeArguments();
+
+    AbstractType& type = AbstractType::Handle(
+        Z, Type::New(klass, type_arguments, TokenPosition::kNoSource));
+    type = ClassFinalizer::FinalizeType(klass, type);
+
+    if (type.IsMalbounded()) {
+      // Evaluate expressions for correctness.
+      instructions +=
+          BuildArgumentsFromActualArguments(NULL, false, /*do_drop*/ true);
+
+      // Throw an error & keep the [Value] on the stack.
+      instructions += ThrowTypeError();
+
+      // Bail out early.
+      return instructions;
+    }
+
+    SetOffset(offset);
+  }
+
+  if (klass.NumTypeArguments() > 0) {
+    const TypeArguments& type_arguments = PeekArgumentsInstantiatedType(klass);
+    if (!klass.IsGeneric()) {
+      Type& type = Type::ZoneHandle(Z, T.ReceiverType(klass).raw());
+
+      // TODO(27590): Can we move this code into [ReceiverType]?
+      type ^= ClassFinalizer::FinalizeType(*active_class()->klass, type,
+                                           ClassFinalizer::kFinalize);
+      ASSERT(!type.IsMalformedOrMalbounded());
+
+      TypeArguments& canonicalized_type_arguments =
+          TypeArguments::ZoneHandle(Z, type.arguments());
+      canonicalized_type_arguments =
+          canonicalized_type_arguments.Canonicalize();
+      instructions += Constant(canonicalized_type_arguments);
+    } else {
+      instructions += TranslateInstantiatedTypeArguments(type_arguments);
+    }
+
+    instructions += PushArgument();
+    instructions += AllocateObject(klass, 1);
+  } else {
+    instructions += AllocateObject(klass, 0);
+  }
+  LocalVariable* variable = MakeTemporary();
+
+  instructions += LoadLocal(variable);
+  instructions += PushArgument();
+
+  Array& argument_names = Array::ZoneHandle(Z);
+  intptr_t argument_count;
+  instructions +=
+      BuildArguments(&argument_names, &argument_count);  // read arguments.
+
+  const Function& target = Function::ZoneHandle(
+      Z, H.LookupConstructorByKernelConstructor(klass, kernel_name));
+  ++argument_count;
+  instructions += StaticCall(position, target, argument_count, argument_names);
+  return instructions + Drop();
+}
+
+Fragment StreamingFlowGraphBuilder::BuildNot() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  Fragment instructions = BuildExpression();  // read expression.
+  instructions += CheckBooleanInCheckedMode();
+  instructions += BooleanNegate();
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildLogicalExpression() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  bool negate;
+  Fragment instructions = TranslateCondition(&negate);  // read left.
+
+  TargetEntryInstr* right_entry;
+  TargetEntryInstr* constant_entry;
+  LogicalOperator op = static_cast<LogicalOperator>(ReadByte());
+
+  if (op == kAnd) {
+    instructions += BranchIfTrue(&right_entry, &constant_entry, negate);
+  } else {
+    instructions += BranchIfTrue(&constant_entry, &right_entry, negate);
+  }
+
+  Value* top = stack();
+  Fragment right_fragment(right_entry);
+  right_fragment += TranslateCondition(&negate);  // read right.
+
+  right_fragment += Constant(Bool::True());
+  right_fragment +=
+      StrictCompare(negate ? Token::kNE_STRICT : Token::kEQ_STRICT);
+  right_fragment += StoreLocal(TokenPosition::kNoSource,
+                               parsed_function()->expression_temp_var());
+  right_fragment += Drop();
+
+  ASSERT(top == stack());
+  Fragment constant_fragment(constant_entry);
+  constant_fragment += Constant(Bool::Get(op == kOr));
+  constant_fragment += StoreLocal(TokenPosition::kNoSource,
+                                  parsed_function()->expression_temp_var());
+  constant_fragment += Drop();
+
+  JoinEntryInstr* join = BuildJoinEntry();
+  right_fragment += Goto(join);
+  constant_fragment += Goto(join);
+
+  return Fragment(instructions.entry, join) +
+         LoadLocal(parsed_function()->expression_temp_var());
+}
+
+Fragment StreamingFlowGraphBuilder::BuildConditionalExpression() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  bool negate;
+  Fragment instructions = TranslateCondition(&negate);  // read condition.
+
+  TargetEntryInstr* then_entry;
+  TargetEntryInstr* otherwise_entry;
+  instructions += BranchIfTrue(&then_entry, &otherwise_entry, negate);
+
+  Value* top = stack();
+  Fragment then_fragment(then_entry);
+  then_fragment += BuildExpression();  // read then.
+  then_fragment += StoreLocal(TokenPosition::kNoSource,
+                              parsed_function()->expression_temp_var());
+  then_fragment += Drop();
+  ASSERT(stack() == top);
+
+  Fragment otherwise_fragment(otherwise_entry);
+  otherwise_fragment += BuildExpression();  // read otherwise.
+  otherwise_fragment += StoreLocal(TokenPosition::kNoSource,
+                                   parsed_function()->expression_temp_var());
+  otherwise_fragment += Drop();
+  ASSERT(stack() == top);
+
+  JoinEntryInstr* join = BuildJoinEntry();
+  then_fragment += Goto(join);
+  otherwise_fragment += Goto(join);
+
+  SkipOptionalDartType();  // read unused static type.
+
+  return Fragment(instructions.entry, join) +
+         LoadLocal(parsed_function()->expression_temp_var());
+}
+
+Fragment StreamingFlowGraphBuilder::BuildStringConcatenation() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  intptr_t length = ReadListLength();  // read list length.
+  // Note: there will be "length" expressions.
+
+  Fragment instructions;
+  if (length == 1) {
+    instructions += BuildExpression();  // read expression.
+    instructions += StringInterpolateSingle(position);
+  } else {
+    // The type arguments for CreateArray.
+    instructions += Constant(TypeArguments::ZoneHandle(Z));
+    instructions += IntConstant(length);
+    instructions += CreateArray();
+    LocalVariable* array = MakeTemporary();
+
+    for (intptr_t i = 0; i < length; ++i) {
+      instructions += LoadLocal(array);
+      instructions += IntConstant(i);
+      instructions += BuildExpression();  // read ith expression.
+      instructions += StoreIndexed(kArrayCid);
+      instructions += Drop();
+    }
+
+    instructions += StringInterpolate(position);
+  }
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildIsExpression() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions = BuildExpression();  // read operand.
+
+  const AbstractType& type = T.BuildType();  // read type.
+
+  // The VM does not like an instanceOf call with a dynamic type. We need to
+  // special case this situation.
+  const Type& object_type = Type::Handle(Z, Type::ObjectType());
+
+  if (type.IsMalformed()) {
+    instructions += Drop();
+    instructions += ThrowTypeError();
+    return instructions;
+  }
+
+  if (type.IsInstantiated() &&
+      object_type.IsSubtypeOf(type, NULL, NULL, Heap::kOld)) {
+    // Evaluate the expression on the left but ignore it's result.
+    instructions += Drop();
+
+    // Let condition be always true.
+    instructions += Constant(Bool::True());
+  } else {
+    instructions += PushArgument();
+
+    // See if simple instanceOf is applicable.
+    if (dart::FlowGraphBuilder::SimpleInstanceOfType(type)) {
+      instructions += Constant(type);
+      instructions += PushArgument();  // Type.
+      instructions += InstanceCall(position, dart::Library::PrivateCoreLibName(
+                                                 Symbols::_simpleInstanceOf()),
+                                   Token::kIS, 2, 2);  // 2 checked arguments.
+      return instructions;
+    }
+
+    if (!type.IsInstantiated(kCurrentClass)) {
+      instructions += LoadInstantiatorTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Instantiator type arguments.
+
+    if (!type.IsInstantiated(kFunctions)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Function type arguments.
+
+    instructions += Constant(type);
+    instructions += PushArgument();  // Type.
+
+    instructions += InstanceCall(
+        position, dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
+        Token::kIS, 4);
+  }
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildAsExpression() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions = BuildExpression();  // read operand.
+
+  const AbstractType& type = T.BuildType();  // read type.
+
+  // The VM does not like an Object_as call with a dynamic type. We need to
+  // special case this situation.
+  const Type& object_type = Type::Handle(Z, Type::ObjectType());
+
+  if (type.IsMalformed()) {
+    instructions += Drop();
+    instructions += ThrowTypeError();
+    return instructions;
+  }
+
+  if (type.IsInstantiated() &&
+      object_type.IsSubtypeOf(type, NULL, NULL, Heap::kOld)) {
+    // We already evaluated the operand on the left and just leave it there as
+    // the result of the `obj as dynamic` expression.
+  } else {
+    instructions += PushArgument();
+
+    if (!type.IsInstantiated(kCurrentClass)) {
+      instructions += LoadInstantiatorTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Instantiator type arguments.
+
+    if (!type.IsInstantiated(kFunctions)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Function type arguments.
+
+    instructions += Constant(type);
+    instructions += PushArgument();  // Type.
+
+    instructions += InstanceCall(
+        position, dart::Library::PrivateCoreLibName(Symbols::_as()), Token::kAS,
+        4);
+  }
+  return instructions;
+}
 
 Fragment StreamingFlowGraphBuilder::BuildSymbolLiteral() {
-  SkipBytes(-1);  // EvaluateExpression needs the tag.
-  return Constant(constant_evaluator_.EvaluateExpression());
-}
-
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  intptr_t offset = ReaderOffset() - 1;  // EvaluateExpression needs the tag.
+  ReadUInt();                            // read index into string table.
+  return Constant(constant_evaluator_.EvaluateExpression(offset));
+}
+
+Fragment StreamingFlowGraphBuilder::BuildTypeLiteral() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  const AbstractType& type = T.BuildType();  // read type.
+  if (type.IsMalformed()) H.ReportError("Malformed type literal");
+
+  Fragment instructions;
+  if (type.IsInstantiated()) {
+    instructions += Constant(type);
+  } else {
+    if (!type.IsInstantiated(kCurrentClass)) {
+      instructions += LoadInstantiatorTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    if (!type.IsInstantiated(kFunctions)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += InstantiateType(type);
+  }
+  return instructions;
+}
 
 Fragment StreamingFlowGraphBuilder::BuildThisExpression() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
   return LoadLocal(scopes()->this_variable);
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildRethrow() {
-  TokenPosition position = ReadPosition();
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
   Fragment instructions = DebugStepCheck(position);
   instructions += LoadLocal(catch_block()->exception_var());
   instructions += PushArgument();
   instructions += LoadLocal(catch_block()->stack_trace_var());
   instructions += PushArgument();
   instructions += RethrowException(position, catch_block()->catch_try_index());
 
   return instructions;
 }
 
+Fragment StreamingFlowGraphBuilder::BuildThrow() {
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  Fragment instructions;
+
+  instructions += BuildExpression();  // read expression.
+
+  if (NeedsDebugStepCheck(stack(), position)) {
+    instructions = DebugStepCheck(position) + instructions;
+  }
+  instructions += PushArgument();
+  instructions += ThrowException(position);
+  ASSERT(instructions.is_closed());
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildListLiteral(bool is_const) {
+  if (is_const) {
+    intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+    UpdateDirectDescendantPosition(ReadPosition());
+
+    SetOffset(offset);
+    SkipExpression();  // read past the ListLiteral.
+    return Constant(constant_evaluator_.EvaluateListLiteral(offset));
+  }
+
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  const TypeArguments& type_arguments = T.BuildTypeArguments(1);  // read type.
+  intptr_t length = ReadListLength();  // read list length.
+  // Note: there will be "length" expressions.
+
+  // The type argument for the factory call.
+  Fragment instructions = TranslateInstantiatedTypeArguments(type_arguments);
+  instructions += PushArgument();
+  if (length == 0) {
+    instructions += Constant(Object::empty_array());
+  } else {
+    // The type arguments for CreateArray.
+    instructions += Constant(TypeArguments::ZoneHandle(Z));
+    instructions += IntConstant(length);
+    instructions += CreateArray();
+
+    LocalVariable* array = MakeTemporary();
+    for (intptr_t i = 0; i < length; ++i) {
+      instructions += LoadLocal(array);
+      instructions += IntConstant(i);
+      instructions += BuildExpression();  // read ith expression.
+      instructions += StoreIndexed(kArrayCid);
+      instructions += Drop();
+    }
+  }
+  instructions += PushArgument();  // The array.
+
+  const dart::Class& factory_class =
+      dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::List()));
+  const Function& factory_method = Function::ZoneHandle(
+      Z, factory_class.LookupFactory(
+             dart::Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
+
+  return instructions + StaticCall(position, factory_method, 2);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildMapLiteral(bool is_const) {
+  if (is_const) {
+    intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+    UpdateDirectDescendantPosition(ReadPosition());
+
+    SetOffset(offset);
+    SkipExpression();  // Read past the MapLiteral.
+    return Constant(constant_evaluator_.EvaluateMapLiteral(offset));
+  }
+
+  TokenPosition position = ReadPosition();  // read position.
+  UpdateDirectDescendantPosition(position);
+
+  const TypeArguments& type_arguments =
+      T.BuildTypeArguments(2);  // read key_type and value_type.
+
+  // The type argument for the factory call `new Map<K, V>._fromLiteral(List)`.
+  Fragment instructions = TranslateInstantiatedTypeArguments(type_arguments);
+  instructions += PushArgument();
+
+  intptr_t length = ReadListLength();  // read list length.
+  // Note: there will be "length" map entries (i.e. key and value expressions).
+
+  if (length == 0) {
+    instructions += Constant(Object::empty_array());
+  } else {
+    // The type arguments for `new List<X>(int len)`.
+    instructions += Constant(TypeArguments::ZoneHandle(Z));
+
+    // We generate a list of tuples, i.e. [key1, value1, ..., keyN, valueN].
+    instructions += IntConstant(2 * length);
+    instructions += CreateArray();
+
+    LocalVariable* array = MakeTemporary();
+    for (intptr_t i = 0; i < length; ++i) {
+      instructions += LoadLocal(array);
+      instructions += IntConstant(2 * i);
+      instructions += BuildExpression();  // read ith key.
+      instructions += StoreIndexed(kArrayCid);
+      instructions += Drop();
+
+      instructions += LoadLocal(array);
+      instructions += IntConstant(2 * i + 1);
+      instructions += BuildExpression();  // read ith value.
+      instructions += StoreIndexed(kArrayCid);
+      instructions += Drop();
+    }
+  }
+  instructions += PushArgument();  // The array.
+
+
+  const dart::Class& map_class =
+      dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::Map()));
+  const Function& factory_method = Function::ZoneHandle(
+      Z, map_class.LookupFactory(
+             dart::Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
+
+  return instructions + StaticCall(position, factory_method, 2);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildLet() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  Fragment instructions = BuildVariableDeclaration(false);  // read variable.
+  instructions += BuildExpression();                        // read body.
+  return instructions;
+}
+
 
 Fragment StreamingFlowGraphBuilder::BuildBigIntLiteral() {
-  const dart::String& value = H.DartString(ReadUInt());
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  const dart::String& value =
+      H.DartString(ReadUInt());  // read string reference.
   return Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildStringLiteral() {
-  intptr_t str_index = ReadUInt();
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  intptr_t str_index = ReadUInt();  // read string reference.
   return Constant(H.DartSymbol(str_index));
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildIntLiteral(uint8_t payload) {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
   int64_t value = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
   return IntConstant(value);
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildIntLiteral(bool is_negative) {
-  int64_t value = is_negative ? -static_cast<int64_t>(ReadUInt()) : ReadUInt();
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  int64_t value = is_negative ? -static_cast<int64_t>(ReadUInt())
+                              : ReadUInt();  // read value.
   return IntConstant(value);
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildDoubleLiteral() {
-  SkipBytes(-1);  // EvaluateExpression needs the tag.
-  return Constant(constant_evaluator_.EvaluateExpression());
-}
-
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  intptr_t offset = ReaderOffset() - 1;  // EvaluateExpression needs the tag.
+  ReadUInt();                            // read index into string table.
+  return Constant(constant_evaluator_.EvaluateExpression(offset));
+}
 
 Fragment StreamingFlowGraphBuilder::BuildBoolLiteral(bool value) {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
   return Constant(Bool::Get(value));
 }
 
-
 Fragment StreamingFlowGraphBuilder::BuildNullLiteral() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
+Fragment StreamingFlowGraphBuilder::BuildInvalidStatement() {
+  UpdateDirectDescendantPosition(TokenPosition::kNoSource);
+
+  H.ReportError("Invalid statements not implemented yet!");
+  return Fragment();
+}
+
+Fragment StreamingFlowGraphBuilder::BuildExpressionStatement() {
+  Fragment instructions = BuildExpression();  // read expression.
+  instructions += Drop();
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildBlock() {
+  intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+
+  Fragment instructions;
+
+  instructions += EnterScope(offset);
+  intptr_t list_length = ReadListLength();  // read number of statements.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    if (instructions.is_open()) {
+      instructions += BuildStatement();  // read ith statement.
+    } else {
+      SkipStatement();  // read ith statement.
+    }
+  }
+  instructions += ExitScope(offset);
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildEmptyStatement() {
+  return Fragment();
+}
+
+Fragment StreamingFlowGraphBuilder::BuildAssertStatement() {
+  if (!I->asserts()) {
+    intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+    SetOffset(offset);
+    SkipStatement();  // read this statement.
+    return Fragment();
+  }
+
+  TargetEntryInstr* then;
+  TargetEntryInstr* otherwise;
+
+  Fragment instructions;
+  // Asserts can be of the following two kinds:
+  //
+  //    * `assert(expr)`
+  //    * `assert(() { ... })`
+  //
+  // The call to `_AssertionError._evaluateAssertion()` will take care of both
+  // and returns a boolean.
+  instructions += BuildExpression();  // read condition.
+  instructions += PushArgument();
+  instructions += EvaluateAssertion();
+  instructions += CheckBooleanInCheckedMode();
+  instructions += Constant(Bool::True());
+  instructions += BranchIfEqual(&then, &otherwise, false);
+
+  const dart::Class& klass = dart::Class::ZoneHandle(
+      Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
+  ASSERT(!klass.IsNull());
+  const dart::Function& constructor = dart::Function::ZoneHandle(
+      Z, klass.LookupConstructorAllowPrivate(
+             H.DartSymbol("_AssertionError._create")));
+  ASSERT(!constructor.IsNull());
+
+  const dart::String& url = H.DartString(
+      parsed_function()->function().ToLibNamePrefixedQualifiedCString(),
+      Heap::kOld);
+
+  // Create instance of _AssertionError
+  Fragment otherwise_fragment(otherwise);
+  otherwise_fragment += AllocateObject(klass, 0);
+  LocalVariable* instance = MakeTemporary();
+
+  // Call _AssertionError._create constructor.
+  otherwise_fragment += LoadLocal(instance);
+  otherwise_fragment += PushArgument();  // this
+
+  otherwise_fragment += Constant(H.DartString("<no message>", Heap::kOld));
+  otherwise_fragment += PushArgument();  // failedAssertion
+
+  otherwise_fragment += Constant(url);
+  otherwise_fragment += PushArgument();  // url
+
+  otherwise_fragment += IntConstant(0);
+  otherwise_fragment += PushArgument();  // line
+
+  otherwise_fragment += IntConstant(0);
+  otherwise_fragment += PushArgument();  // column
+
+  Tag tag = ReadTag();  // read (first part of) message.
+  if (tag == kSomething) {
+    otherwise_fragment += BuildExpression();  // read (rest of) message.
+  } else {
+    otherwise_fragment += Constant(H.DartString("<no message>", Heap::kOld));
+  }
+  otherwise_fragment += PushArgument();  // message
+
+  otherwise_fragment += StaticCall(TokenPosition::kNoSource, constructor, 6);
+  otherwise_fragment += Drop();
+
+  // Throw _AssertionError exception.
+  otherwise_fragment += PushArgument();
+  otherwise_fragment += ThrowException(TokenPosition::kNoSource);
+  otherwise_fragment += Drop();
+
+  return Fragment(instructions.entry, then);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildLabeledStatement() {
+  // There can be serveral cases:
+  //
+  //   * the body contains a break
+  //   * the body doesn't contain a break
+  //
+  //   * translating the body results in a closed fragment
+  //   * translating the body results in a open fragment
+  //
+  // => We will only know which case we are in after the body has been
+  //    traversed.
+
+  BreakableBlock block(flow_graph_builder_);
+  Fragment instructions = BuildStatement();  // read body.
+  if (block.HadJumper()) {
+    if (instructions.is_open()) {
+      instructions += Goto(block.destination());
+    }
+    return Fragment(instructions.entry, block.destination());
+  } else {
+    return instructions;
+  }
+}
+
+Fragment StreamingFlowGraphBuilder::BuildBreakStatement() {
+  TokenPosition position = ReadPosition();  // read position.
+  intptr_t target_index = ReadUInt();       // read target index.
+
+  TryFinallyBlock* outer_finally = NULL;
+  intptr_t target_context_depth = -1;
+  JoinEntryInstr* destination = breakable_block()->BreakDestination(
+      target_index, &outer_finally, &target_context_depth);
+
+  Fragment instructions;
+  instructions +=
+      TranslateFinallyFinalizers(outer_finally, target_context_depth);
+  if (instructions.is_open()) {
+    if (NeedsDebugStepCheck(parsed_function()->function(), position)) {
+      instructions += DebugStepCheck(position);
+    }
+    instructions += Goto(destination);
+  }
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildWhileStatement() {
+  loop_depth_inc();
+  bool negate;
+  Fragment condition = TranslateCondition(&negate);  // read condition.
+  TargetEntryInstr* body_entry;
+  TargetEntryInstr* loop_exit;
+  condition += BranchIfTrue(&body_entry, &loop_exit, negate);
+
+  Fragment body(body_entry);
+  body += BuildStatement();  // read body.
+
+  Instruction* entry;
+  if (body.is_open()) {
+    JoinEntryInstr* join = BuildJoinEntry();
+    body += Goto(join);
+
+    Fragment loop(join);
+    loop += CheckStackOverflow();
+    loop += condition;
+    entry = new (Z) GotoInstr(join);
+  } else {
+    entry = condition.entry;
+  }
+
+
+  loop_depth_dec();
+  return Fragment(entry, loop_exit);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildDoStatement() {
+  loop_depth_inc();
+  Fragment body = BuildStatement();  // read body.
+
+  if (body.is_closed()) {
+    SkipExpression();  // read condition.
+    loop_depth_dec();
+    return body;
+  }
+
+  bool negate;
+  JoinEntryInstr* join = BuildJoinEntry();
+  Fragment loop(join);
+  loop += CheckStackOverflow();
+  loop += body;
+  loop += TranslateCondition(&negate);  // read condition.
+  TargetEntryInstr* loop_repeat;
+  TargetEntryInstr* loop_exit;
+  loop += BranchIfTrue(&loop_repeat, &loop_exit, negate);
+
+  Fragment repeat(loop_repeat);
+  repeat += Goto(join);
+
+  loop_depth_dec();
+  return Fragment(new (Z) GotoInstr(join), loop_exit);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildForStatement() {
+  intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+
+  Fragment declarations;
+
+  bool new_context = false;
+  declarations += EnterScope(offset, &new_context);
+
+  intptr_t list_length = ReadListLength();  // read number of variables.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    declarations += BuildVariableDeclaration(false);  // read ith variable.
+  }
+
+  loop_depth_inc();
+  bool negate = false;
+  Tag tag = ReadTag();  // Read first part of condition.
+  Fragment condition =
+      tag == kNothing ? Constant(Bool::True())
+                      : TranslateCondition(&negate);  // read rest of condition.
+  TargetEntryInstr* body_entry;
+  TargetEntryInstr* loop_exit;
+  condition += BranchIfTrue(&body_entry, &loop_exit, negate);
+
+  Fragment updates;
+  list_length = ReadListLength();  // read number of updates.
+  for (intptr_t i = 0; i < list_length; ++i) {
+    updates += BuildExpression();  // read ith update.
+    updates += Drop();
+  }
+
+  Fragment body(body_entry);
+  body += BuildStatement();  // read body.
+
+  if (body.is_open()) {
+    // We allocated a fresh context before the loop which contains captured
+    // [ForStatement] variables.  Before jumping back to the loop entry we clone
+    // the context object (at same depth) which ensures the next iteration of
+    // the body gets a fresh set of [ForStatement] variables (with the old
+    // (possibly updated) values).
+    if (new_context) body += CloneContext();
+
+    body += updates;
+    JoinEntryInstr* join = BuildJoinEntry();
+    declarations += Goto(join);
+    body += Goto(join);
+
+    Fragment loop(join);
+    loop += CheckStackOverflow();
+    loop += condition;
+  } else {
+    declarations += condition;
+  }
+
+  Fragment loop(declarations.entry, loop_exit);
+  loop_depth_dec();
+
+  loop += ExitScope(offset);
+
+  return loop;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildForInStatement(bool async) {
+  intptr_t offset = ReaderOffset() - 1;  // Include the tag.
+
+  TokenPosition position = ReadPosition();  // read position.
+  intptr_t variable_kernel_position = ReaderOffset();
+  SkipVariableDeclaration();  // read variable.
+  TokenPosition org_direct_descendant_position = direct_descendant_position_;
+  ResetDirectDescendantPosition();
+
+  Fragment instructions = BuildExpression();  // read iterable.
+  instructions += PushArgument();
+
+  TokenPosition iterable_position = direct_descendant_position_;
+  direct_descendant_position_ = org_direct_descendant_position;
+
+  const dart::String& iterator_getter = dart::String::ZoneHandle(
+      Z, dart::Field::GetterSymbol(Symbols::Iterator()));
+  instructions +=
+      InstanceCall(iterable_position, iterator_getter, Token::kGET, 1);
+  LocalVariable* iterator = scopes()->iterator_variables[for_in_depth()];
+  instructions += StoreLocal(TokenPosition::kNoSource, iterator);
+  instructions += Drop();
+
+  for_in_depth_inc();
+  loop_depth_inc();
+  Fragment condition = LoadLocal(iterator);
+  condition += PushArgument();
+  condition +=
+      InstanceCall(iterable_position, Symbols::MoveNext(), Token::kILLEGAL, 1);
+  TargetEntryInstr* body_entry;
+  TargetEntryInstr* loop_exit;
+  condition += BranchIfTrue(&body_entry, &loop_exit, false);
+
+  Fragment body(body_entry);
+  body += EnterScope(offset);
+  body += LoadLocal(iterator);
+  body += PushArgument();
+  const dart::String& current_getter = dart::String::ZoneHandle(
+      Z, dart::Field::GetterSymbol(Symbols::Current()));
+  body += InstanceCall(position, current_getter, Token::kGET, 1);
+  body += StoreLocal(TokenPosition::kNoSource,
+                     LookupVariable(variable_kernel_position));
+  body += Drop();
+  body += BuildStatement();  // read body.
+  body += ExitScope(offset);
+
+  if (body.is_open()) {
+    JoinEntryInstr* join = BuildJoinEntry();
+    instructions += Goto(join);
+    body += Goto(join);
+
+    Fragment loop(join);
+    loop += CheckStackOverflow();
+    loop += condition;
+  } else {
+    instructions += condition;
+  }
+
+  loop_depth_dec();
+  for_in_depth_dec();
+  return Fragment(instructions.entry, loop_exit);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildSwitchStatement() {
+  // We need the number of cases. So start by getting that, then go back.
+  intptr_t offset = ReaderOffset();
+  SkipExpression();                  // temporarily skip condition
+  int num_cases = ReadListLength();  // read number of cases.
+  SetOffset(offset);
+
+  SwitchBlock block(flow_graph_builder_, num_cases);
+
+  // Instead of using a variable we should reuse the expression on the stack,
+  // since it won't be assigned again, we don't need phi nodes.
+  Fragment head_instructions = BuildExpression();  // read condition.
+  head_instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes()->switch_variable);
+  head_instructions += Drop();
+
+  num_cases = ReadListLength();  // read number of cases.
+
+  // Phase 1: Generate bodies and try to find out whether a body will be target
+  // of a jump due to:
+  //   * `continue case_label`
+  //   * `case e1: case e2: body`
+  Fragment* body_fragments = new Fragment[num_cases];
+  intptr_t* case_expression_offsets = new intptr_t[num_cases];
+  bool* case_is_default = new bool[num_cases];
+
+  for (intptr_t i = 0; i < num_cases; ++i) {
+    case_expression_offsets[i] = ReaderOffset();
+    int num_expressions = ReadListLength();  // read number of expressions.
+    for (intptr_t j = 0; j < num_expressions; ++j) {
+      ReadPosition();    // read jth position.
+      SkipExpression();  // read jth expression.
+    }
+    bool is_default = ReadBool();  // read is_default.
+    case_is_default[i] = is_default;
+    Fragment& body_fragment = body_fragments[i] =
+        BuildStatement();  // read body.
+
+    if (body_fragment.entry == NULL) {
+      // Make a NOP in order to ensure linking works properly.
+      body_fragment = NullConstant();
+      body_fragment += Drop();
+    }
+
+    // The Dart language specification mandates fall-throughs in [SwitchCase]es
+    // to be runtime errors.
+    if (!is_default && body_fragment.is_open() && (i < (num_cases - 1))) {
+      const dart::Class& klass = dart::Class::ZoneHandle(
+          Z, dart::Library::LookupCoreClass(Symbols::FallThroughError()));
+      ASSERT(!klass.IsNull());
+      const dart::Function& constructor = dart::Function::ZoneHandle(
+          Z, klass.LookupConstructorAllowPrivate(
+                 H.DartSymbol("FallThroughError._create")));
+      ASSERT(!constructor.IsNull());
+      const dart::String& url = H.DartString(
+          parsed_function()->function().ToLibNamePrefixedQualifiedCString(),
+          Heap::kOld);
+
+      // Create instance of _FallThroughError
+      body_fragment += AllocateObject(klass, 0);
+      LocalVariable* instance = MakeTemporary();
+
+      // Call _FallThroughError._create constructor.
+      body_fragment += LoadLocal(instance);
+      body_fragment += PushArgument();  // this
+
+      body_fragment += Constant(url);
+      body_fragment += PushArgument();  // url
+
+      body_fragment += NullConstant();
+      body_fragment += PushArgument();  // line
+
+      body_fragment += StaticCall(TokenPosition::kNoSource, constructor, 3);
+      body_fragment += Drop();
+
+      // Throw the exception
+      body_fragment += PushArgument();
+      body_fragment += ThrowException(TokenPosition::kNoSource);
+      body_fragment += Drop();
+    }
+
+    // If there is an implicit fall-through we have one [SwitchCase] and
+    // multiple expressions, e.g.
+    //
+    //    switch(expr) {
+    //      case a:
+    //      case b:
+    //        <stmt-body>
+    //    }
+    //
+    // This means that the <stmt-body> will have more than 1 incoming edge (one
+    // from `a == expr` and one from `a != expr && b == expr`). The
+    // `block.Destination()` records the additional jump.
+    if (num_expressions > 1) {
+      block.DestinationDirect(i);
+    }
+  }
+
+  intptr_t end_offset = ReaderOffset();
+
+  // Phase 2: Generate everything except the real bodies:
+  //   * jump directly to a body (if there is no jumper)
+  //   * jump to a wrapper block which jumps to the body (if there is a jumper)
+  Fragment current_instructions = head_instructions;
+  for (intptr_t i = 0; i < num_cases; ++i) {
+    SetOffset(case_expression_offsets[i]);
+    int num_expressions = ReadListLength();  // read length of expressions.
+
+    if (case_is_default[i]) {
+      ASSERT(i == (num_cases - 1));
+
+      // Evaluate the conditions for the default [SwitchCase] just for the
+      // purpose of potentially triggering a compile-time error.
+
+      for (intptr_t j = 0; j < num_expressions; ++j) {
+        ReadPosition();  // read jth position.
+        // this reads the expression, but doesn't skip past it.
+        constant_evaluator_.EvaluateExpression(ReaderOffset());
+        SkipExpression();  // read jth expression.
+      }
+
+      if (block.HadJumper(i)) {
+        // There are several branches to the body, so we will make a goto to
+        // the join block (and prepend a join instruction to the real body).
+        JoinEntryInstr* join = block.DestinationDirect(i);
+        current_instructions += Goto(join);
+
+        current_instructions = Fragment(current_instructions.entry, join);
+        current_instructions += body_fragments[i];
+      } else {
+        current_instructions += body_fragments[i];
+      }
+    } else {
+      JoinEntryInstr* body_join = NULL;
+      if (block.HadJumper(i)) {
+        body_join = block.DestinationDirect(i);
+        body_fragments[i] = Fragment(body_join) + body_fragments[i];
+      }
+
+      for (intptr_t j = 0; j < num_expressions; ++j) {
+        TargetEntryInstr* then;
+        TargetEntryInstr* otherwise;
+
+        TokenPosition position = ReadPosition();  // read jth position.
+        current_instructions +=
+            Constant(constant_evaluator_.EvaluateExpression(ReaderOffset()));
+        SkipExpression();  // read jth expression.
+        current_instructions += PushArgument();
+        current_instructions += LoadLocal(scopes()->switch_variable);
+        current_instructions += PushArgument();
+        current_instructions +=
+            InstanceCall(position, Symbols::EqualOperator(), Token::kEQ,
+                         /*argument_count=*/2,
+                         /*num_args_checked=*/2);
+        current_instructions += BranchIfTrue(&then, &otherwise, false);
+
+        Fragment then_fragment(then);
+
+        if (body_join != NULL) {
+          // There are several branches to the body, so we will make a goto to
+          // the join block (the real body has already been prepended with a
+          // join instruction).
+          then_fragment += Goto(body_join);
+        } else {
+          // There is only a signle branch to the body, so we will just append
+          // the body fragment.
+          then_fragment += body_fragments[i];
+        }
+
+        current_instructions = Fragment(otherwise);
+      }
+    }
+  }
+
+  bool has_no_default = num_cases > 0 && !case_is_default[num_cases - 1];
+  if (has_no_default) {
+    // There is no default, which means we have an open [current_instructions]
+    // (which is a [TargetEntryInstruction] for the last "otherwise" branch).
+    //
+    // Furthermore the last [SwitchCase] can be open as well.  If so, we need
+    // to join these two.
+    Fragment& last_body = body_fragments[num_cases - 1];
+    if (last_body.is_open()) {
+      ASSERT(current_instructions.is_open());
+      ASSERT(current_instructions.current->IsTargetEntry());
+
+      // Join the last "otherwise" branch and the last [SwitchCase] fragment.
+      JoinEntryInstr* join = BuildJoinEntry();
+      current_instructions += Goto(join);
+      last_body += Goto(join);
+
+      current_instructions = Fragment(join);
+    }
+  } else {
+    // All non-default cases will be closed (i.e. break/continue/throw/return)
+    // So it is fine to just let more statements after the switch append to the
+    // default case.
+  }
+
+  delete[] body_fragments;
+
+  SetOffset(end_offset);
+  return Fragment(head_instructions.entry, current_instructions.current);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildContinueSwitchStatement() {
+  intptr_t target_index = ReadUInt();  // read target index.
+
+  TryFinallyBlock* outer_finally = NULL;
+  intptr_t target_context_depth = -1;
+  JoinEntryInstr* entry = switch_block()->Destination(
+      target_index, &outer_finally, &target_context_depth);
+
+  Fragment instructions;
+  instructions +=
+      TranslateFinallyFinalizers(outer_finally, target_context_depth);
+  if (instructions.is_open()) {
+    instructions += Goto(entry);
+  }
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildIfStatement() {
+  bool negate;
+  Fragment instructions = TranslateCondition(&negate);  // read condition.
+  TargetEntryInstr* then_entry;
+  TargetEntryInstr* otherwise_entry;
+  instructions += BranchIfTrue(&then_entry, &otherwise_entry, negate);
+
+  Fragment then_fragment(then_entry);
+  then_fragment += BuildStatement();  // read then.
+
+  Fragment otherwise_fragment(otherwise_entry);
+  otherwise_fragment += BuildStatement();  // read otherwise.
+
+  if (then_fragment.is_open()) {
+    if (otherwise_fragment.is_open()) {
+      JoinEntryInstr* join = BuildJoinEntry();
+      then_fragment += Goto(join);
+      otherwise_fragment += Goto(join);
+      return Fragment(instructions.entry, join);
+    } else {
+      return Fragment(instructions.entry, then_fragment.current);
+    }
+  } else if (otherwise_fragment.is_open()) {
+    return Fragment(instructions.entry, otherwise_fragment.current);
+  } else {
+    return instructions.closed();
+  }
+}
+
+Fragment StreamingFlowGraphBuilder::BuildReturnStatement() {
+  TokenPosition position = ReadPosition();  // read position.
+  Tag tag = ReadTag();                      // read first part of expression.
+
+  bool inside_try_finally = try_finally_block() != NULL;
+
+  Fragment instructions = tag == kNothing
+                              ? NullConstant()
+                              : BuildExpression();  // read rest of expression.
+
+  if (instructions.is_open()) {
+    if (inside_try_finally) {
+      ASSERT(scopes()->finally_return_variable != NULL);
+      const Function& function = parsed_function()->function();
+      if (NeedsDebugStepCheck(function, position)) {
+        instructions += DebugStepCheck(position);
+      }
+      instructions += StoreLocal(position, scopes()->finally_return_variable);
+      instructions += Drop();
+      instructions += TranslateFinallyFinalizers(NULL, -1);
+      if (instructions.is_open()) {
+        instructions += LoadLocal(scopes()->finally_return_variable);
+        instructions += Return(TokenPosition::kNoSource);
+      }
+    } else {
+      instructions += Return(position);
+    }
+  } else {
+    Pop();
+  }
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildTryCatch() {
+  InlineBailout("kernel::FlowgraphBuilder::VisitTryCatch");
+
+  intptr_t try_handler_index = AllocateTryIndex();
+  Fragment try_body = TryCatch(try_handler_index);
+  JoinEntryInstr* after_try = BuildJoinEntry();
+
+  // Fill in the body of the try.
+  try_depth_inc();
+  {
+    TryCatchBlock block(flow_graph_builder_, try_handler_index);
+    try_body += BuildStatement();  // read body.
+    try_body += Goto(after_try);
+  }
+  try_depth_dec();
+
+  bool needs_stacktrace = ReadBool();  // read any_catch_needs_stack_trace
+
+  catch_depth_inc();
+  intptr_t num_matches = ReadListLength();  // read number of catches.
+  const Array& handler_types =
+      Array::ZoneHandle(Z, Array::New(num_matches, Heap::kOld));
+  Fragment catch_body =
+      CatchBlockEntry(handler_types, try_handler_index, needs_stacktrace);
+  // Fill in the body of the catch.
+  for (intptr_t i = 0; i < num_matches; ++i) {
+    intptr_t catch_offset = ReaderOffset();  // Catch has no tag.
+    Tag tag = PeekTag();                     // peek guard type.
+    AbstractType* type_guard = NULL;
+    if (tag != kDynamicType) {
+      type_guard = &T.BuildType();  // read guard.
+      handler_types.SetAt(i, *type_guard);
+    } else {
+      SkipDartType();  // read guard.
+      handler_types.SetAt(i, Object::dynamic_type());
+    }
+
+    Fragment catch_handler_body = EnterScope(catch_offset);
+
+    tag = ReadTag();  // read first part of exception.
+    if (tag == kSomething) {
+      catch_handler_body += LoadLocal(CurrentException());
+      catch_handler_body +=
+          StoreLocal(TokenPosition::kNoSource, LookupVariable(ReaderOffset()));
+      catch_handler_body += Drop();
+      SkipVariableDeclaration();  // read exception.
+    }
+
+    tag = ReadTag();  // read first part of stack trace.
+    if (tag == kSomething) {
+      catch_handler_body += LoadLocal(CurrentStackTrace());
+      catch_handler_body +=
+          StoreLocal(TokenPosition::kNoSource, LookupVariable(ReaderOffset()));
+      catch_handler_body += Drop();
+      SkipVariableDeclaration();  // read stack trace.
+    }
+
+    {
+      CatchBlock block(flow_graph_builder_, CurrentException(),
+                       CurrentStackTrace(), try_handler_index);
+
+      catch_handler_body += BuildStatement();  // read body.
+
+      // Note: ExitScope adjusts context_depth_ so even if catch_handler_body
+      // is closed we still need to execute ExitScope for its side effect.
+      catch_handler_body += ExitScope(catch_offset);
+      if (catch_handler_body.is_open()) {
+        catch_handler_body += Goto(after_try);
+      }
+    }
+
+    if (type_guard != NULL) {
+      if (type_guard->IsMalformed()) {
+        catch_body += ThrowTypeError();
+        catch_body += Drop();
+      } else {
+        catch_body += LoadLocal(CurrentException());
+        catch_body += PushArgument();  // exception
+        catch_body += NullConstant();
+        catch_body += PushArgument();  // instantiator type arguments
+        catch_body += NullConstant();
+        catch_body += PushArgument();  // function type arguments
+        catch_body += Constant(*type_guard);
+        catch_body += PushArgument();  // guard type
+        catch_body += InstanceCall(
+            TokenPosition::kNoSource,
+            dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
+            Token::kIS, 4);
+
+        TargetEntryInstr* catch_entry;
+        TargetEntryInstr* next_catch_entry;
+        catch_body += BranchIfTrue(&catch_entry, &next_catch_entry, false);
+
+        Fragment(catch_entry) + catch_handler_body;
+        catch_body = Fragment(next_catch_entry);
+      }
+    } else {
+      catch_body += catch_handler_body;
+    }
+  }
+
+  // In case the last catch body was not handling the exception and branching to
+  // after the try block, we will rethrow the exception (i.e. no default catch
+  // handler).
+  if (catch_body.is_open()) {
+    catch_body += LoadLocal(CurrentException());
+    catch_body += PushArgument();
+    catch_body += LoadLocal(CurrentStackTrace());
+    catch_body += PushArgument();
+    catch_body += RethrowException(TokenPosition::kNoSource, try_handler_index);
+    Drop();
+  }
+  catch_depth_dec();
+
+  return Fragment(try_body.entry, after_try);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildTryFinally() {
+  // Note on streaming:
+  // We only stream this TryFinally if we can stream everything inside it,
+  // so creating a "TryFinallyBlock" with a kernel binary offset instead of an
+  // AST node isn't a problem.
+
+
+  InlineBailout("kernel::FlowgraphBuilder::VisitTryFinally");
+
+  // There are 5 different cases where we need to execute the finally block:
+  //
+  //  a) 1/2/3th case: Special control flow going out of `node->body()`:
+  //
+  //   * [BreakStatement] transfers control to a [LabledStatement]
+  //   * [ContinueSwitchStatement] transfers control to a [SwitchCase]
+  //   * [ReturnStatement] returns a value
+  //
+  //   => All three cases will automatically append all finally blocks
+  //      between the branching point and the destination (so we don't need to
+  //      do anything here).
+  //
+  //  b) 4th case: Translating the body resulted in an open fragment (i.e. body
+  //               executes without any control flow out of it)
+  //
+  //   => We are responsible for jumping out of the body to a new block (with
+  //      different try index) and execute the finalizer.
+  //
+  //  c) 5th case: An exception occurred inside the body.
+  //
+  //   => We are responsible for catching it, executing the finally block and
+  //      rethrowing the exception.
+  intptr_t try_handler_index = AllocateTryIndex();
+  Fragment try_body = TryCatch(try_handler_index);
+  JoinEntryInstr* after_try = BuildJoinEntry();
+
+  intptr_t offset = ReaderOffset();
+  SkipStatement();  // temporarily read body.
+  intptr_t finalizer_offset = ReaderOffset();
+  SetOffset(offset);
+
+  // Fill in the body of the try.
+  try_depth_inc();
+  {
+    TryFinallyBlock tfb(flow_graph_builder_, NULL, finalizer_offset);
+    TryCatchBlock tcb(flow_graph_builder_, try_handler_index);
+    try_body += BuildStatement();  // read body.
+  }
+  try_depth_dec();
+
+  if (try_body.is_open()) {
+    // Please note: The try index will be on level out of this block,
+    // thereby ensuring if there's an exception in the finally block we
+    // won't run it twice.
+    JoinEntryInstr* finally_entry = BuildJoinEntry();
+
+    try_body += Goto(finally_entry);
+
+    Fragment finally_body(finally_entry);
+    finally_body += BuildStatement();  // read finalizer.
+    finally_body += Goto(after_try);
+  }
+
+  // Fill in the body of the catch.
+  catch_depth_inc();
+  const Array& handler_types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
+  handler_types.SetAt(0, Object::dynamic_type());
+  // Note: rethrow will actually force mark the handler as needing a stacktrace.
+  Fragment finally_body = CatchBlockEntry(handler_types, try_handler_index,
+                                          /* needs_stacktrace = */ false);
+  SetOffset(finalizer_offset);
+  finally_body += BuildStatement();  // read finalizer
+  if (finally_body.is_open()) {
+    finally_body += LoadLocal(CurrentException());
+    finally_body += PushArgument();
+    finally_body += LoadLocal(CurrentStackTrace());
+    finally_body += PushArgument();
+    finally_body +=
+        RethrowException(TokenPosition::kNoSource, try_handler_index);
+    Drop();
+  }
+  catch_depth_dec();
+
+  return Fragment(try_body.entry, after_try);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildYieldStatement() {
+  TokenPosition position = ReadPosition();  // read position.
+  uint8_t flags = ReadByte();               // read flags.
+
+  ASSERT((flags & kFlagNative) == kFlagNative);  // Must have been desugared.
+
+  // Setup yield/continue point:
+  //
+  //   ...
+  //   :await_jump_var = index;
+  //   :await_ctx_var = :current_context_var
+  //   return <expr>
+  //
+  // Continuation<index>:
+  //   Drop(1)
+  //   ...
+  //
+  // BuildGraphOfFunction will create a dispatch that jumps to
+  // Continuation<:await_jump_var> upon entry to the function.
+  //
+  Fragment instructions = IntConstant(yield_continuations().length() + 1);
+  instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes()->yield_jump_variable);
+  instructions += Drop();
+  instructions += LoadLocal(parsed_function()->current_context_var());
+  instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes()->yield_context_variable);
+  instructions += Drop();
+  instructions += BuildExpression();  // read expression.
+  instructions += Return(TokenPosition::kNoSource);
+
+  // Note: DropTempsInstr serves as an anchor instruction. It will not
+  // be linked into the resulting graph.
+  DropTempsInstr* anchor = new (Z) DropTempsInstr(0, NULL);
+  yield_continuations().Add(YieldContinuation(anchor, CurrentTryIndex()));
+
+  Fragment continuation(instructions.entry, anchor);
+
+  if (parsed_function()->function().IsAsyncClosure() ||
+      parsed_function()->function().IsAsyncGenClosure()) {
+    // If function is async closure or async gen closure it takes three
+    // parameters where the second and the third are exception and stack_trace.
+    // Check if exception is non-null and rethrow it.
+    //
+    //   :async_op([:result, :exception, :stack_trace]) {
+    //     ...
+    //     Continuation<index>:
+    //       if (:exception != null) rethrow(:exception, :stack_trace);
+    //     ...
+    //   }
+    //
+    LocalScope* scope = parsed_function()->node_sequence()->scope();
+    LocalVariable* exception_var = scope->VariableAt(2);
+    LocalVariable* stack_trace_var = scope->VariableAt(3);
+    ASSERT(exception_var->name().raw() == Symbols::ExceptionParameter().raw());
+    ASSERT(stack_trace_var->name().raw() ==
+           Symbols::StackTraceParameter().raw());
+
+    TargetEntryInstr* no_error;
+    TargetEntryInstr* error;
+
+    continuation += LoadLocal(exception_var);
+    continuation += BranchIfNull(&no_error, &error);
+
+    Fragment rethrow(error);
+    rethrow += LoadLocal(exception_var);
+    rethrow += PushArgument();
+    rethrow += LoadLocal(stack_trace_var);
+    rethrow += PushArgument();
+    rethrow += RethrowException(position, CatchClauseNode::kInvalidTryIndex);
+    Drop();
+
+
+    continuation = Fragment(continuation.entry, no_error);
+  }
+
+  return continuation;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVariableDeclaration(bool has_tag) {
+  intptr_t kernel_position = ReaderOffset() - (has_tag ? 1 : 0);
+  LocalVariable* variable = LookupVariable(kernel_position);
+
+  TokenPosition position = ReadPosition();         // read position.
+  TokenPosition equals_position = ReadPosition();  // read equals position.
+  word flags = ReadFlags();                        // read flags.
+  dart::String& name = H.DartSymbol(ReadUInt());   // read name index.
+  AbstractType& type = T.BuildType();              // read type.
+  Tag tag = ReadTag();  // read (first part of) initializer.
+
+  Fragment instructions;
+  if (tag == kNothing) {
+    instructions += NullConstant();
+  } else {
+    if ((flags & kFlagConst) == kFlagConst) {
+      // Const!
+      const Instance& constant_value = constant_evaluator_.EvaluateExpression(
+          ReaderOffset());  // read initializer form current position.
+      variable->SetConstValue(constant_value);
+      instructions += Constant(constant_value);
+      SkipExpression();  // skip initializer.
+    } else {
+      // Initializer
+      instructions += BuildExpression();  // read (actual) initializer.
+      instructions += CheckVariableTypeInCheckedMode(type, name);
+    }
+  }
+
+  // Use position of equal sign if it exists. If the equal sign does not exist
+  // use the position of the identifier.
+  TokenPosition debug_position = Utils::Maximum(position, equals_position);
+  if (NeedsDebugStepCheck(stack(), debug_position)) {
+    instructions = DebugStepCheck(debug_position) + instructions;
+  }
+  instructions += StoreLocal(position, variable);
+  instructions += Drop();
+  return instructions;
+}
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)