diff --git a/runtime/vm/class_id.h b/runtime/vm/class_id.h
index 4e23dea..f95d77f 100644
--- a/runtime/vm/class_id.h
+++ b/runtime/vm/class_id.h
@@ -36,7 +36,6 @@
   V(ExceptionHandlers)                                                         \
   V(Context)                                                                   \
   V(ContextScope)                                                              \
-  V(ParameterTypeCheck)                                                        \
   V(SingleTargetCache)                                                         \
   V(UnlinkedCall)                                                              \
   V(ICData)                                                                    \
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 39249519..a71b9cb 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -2104,71 +2104,6 @@
 };
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
-class ParameterTypeCheckSerializationCluster : public SerializationCluster {
- public:
-  ParameterTypeCheckSerializationCluster()
-      : SerializationCluster("ParameterTypeCheck") {}
-  ~ParameterTypeCheckSerializationCluster() {}
-
-  void Trace(Serializer* s, RawObject* object) {
-    RawParameterTypeCheck* unlinked = ParameterTypeCheck::RawCast(object);
-    objects_.Add(unlinked);
-    PushFromTo(unlinked);
-  }
-
-  void WriteAlloc(Serializer* s) {
-    s->WriteCid(kParameterTypeCheckCid);
-    intptr_t count = objects_.length();
-    s->WriteUnsigned(count);
-    for (intptr_t i = 0; i < count; i++) {
-      RawParameterTypeCheck* check = objects_[i];
-      s->AssignRef(check);
-    }
-  }
-
-  void WriteFill(Serializer* s) {
-    intptr_t count = objects_.length();
-    for (intptr_t i = 0; i < count; i++) {
-      RawParameterTypeCheck* check = objects_[i];
-      s->Write<intptr_t>(check->ptr()->index_);
-      WriteFromTo(check);
-    }
-  }
-
- private:
-  GrowableArray<RawParameterTypeCheck*> objects_;
-};
-#endif  // !DART_PRECOMPILED_RUNTIME
-
-class ParameterTypeCheckDeserializationCluster : public DeserializationCluster {
- public:
-  ParameterTypeCheckDeserializationCluster() {}
-  ~ParameterTypeCheckDeserializationCluster() {}
-
-  void ReadAlloc(Deserializer* d) {
-    start_index_ = d->next_index();
-    PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->ReadUnsigned();
-    for (intptr_t i = 0; i < count; i++) {
-      d->AssignRef(
-          AllocateUninitialized(old_space, ParameterTypeCheck::InstanceSize()));
-    }
-    stop_index_ = d->next_index();
-  }
-
-  void ReadFill(Deserializer* d) {
-    for (intptr_t id = start_index_; id < stop_index_; id++) {
-      RawParameterTypeCheck* check =
-          reinterpret_cast<RawParameterTypeCheck*>(d->Ref(id));
-      Deserializer::InitializeHeader(check, kParameterTypeCheckCid,
-                                     ParameterTypeCheck::InstanceSize());
-      check->ptr()->index_ = d->Read<intptr_t>();
-      ReadFromTo(check);
-    }
-  }
-};
-
-#if !defined(DART_PRECOMPILED_RUNTIME)
 class UnlinkedCallSerializationCluster : public SerializationCluster {
  public:
   UnlinkedCallSerializationCluster() : SerializationCluster("UnlinkedCall") {}
@@ -4340,8 +4275,6 @@
       return new (Z) ContextSerializationCluster();
     case kContextScopeCid:
       return new (Z) ContextScopeSerializationCluster();
-    case kParameterTypeCheckCid:
-      return new (Z) ParameterTypeCheckSerializationCluster();
     case kUnlinkedCallCid:
       return new (Z) UnlinkedCallSerializationCluster();
     case kICDataCid:
@@ -4779,8 +4712,6 @@
                 "<invoke field>");
   AddBaseObject(Object::nsm_dispatcher_bytecode().raw(), "Bytecode",
                 "<nsm dispatcher>");
-  AddBaseObject(Object::dynamic_invocation_forwarder_bytecode().raw(),
-                "Bytecode", "<dyn forwarder>");
 
   for (intptr_t i = 0; i < ArgumentsDescriptor::kCachedDescriptorCount; i++) {
     AddBaseObject(ArgumentsDescriptor::cached_args_descriptors_[i],
@@ -4974,8 +4905,6 @@
       return new (Z) ContextDeserializationCluster();
     case kContextScopeCid:
       return new (Z) ContextScopeDeserializationCluster();
-    case kParameterTypeCheckCid:
-      return new (Z) ParameterTypeCheckDeserializationCluster();
     case kUnlinkedCallCid:
       return new (Z) UnlinkedCallDeserializationCluster();
     case kICDataCid:
@@ -5245,7 +5174,6 @@
   AddBaseObject(Object::invoke_closure_bytecode().raw());
   AddBaseObject(Object::invoke_field_bytecode().raw());
   AddBaseObject(Object::nsm_dispatcher_bytecode().raw());
-  AddBaseObject(Object::dynamic_invocation_forwarder_bytecode().raw());
 
   for (intptr_t i = 0; i < ArgumentsDescriptor::kCachedDescriptorCount; i++) {
     AddBaseObject(ArgumentsDescriptor::cached_args_descriptors_[i]);
diff --git a/runtime/vm/compiler/frontend/bytecode_reader.cc b/runtime/vm/compiler/frontend/bytecode_reader.cc
index c747fbd..c180689 100644
--- a/runtime/vm/compiler/frontend/bytecode_reader.cc
+++ b/runtime/vm/compiler/frontend/bytecode_reader.cc
@@ -53,7 +53,6 @@
       (function.kind() != RawFunction::kImplicitStaticGetter) &&
       (function.kind() != RawFunction::kMethodExtractor) &&
       (function.kind() != RawFunction::kInvokeFieldDispatcher) &&
-      (function.kind() != RawFunction::kDynamicInvocationForwarder) &&
       (function.kind() != RawFunction::kNoSuchMethodDispatcher)) {
     return;
   }
@@ -270,142 +269,6 @@
   }
 }
 
-static intptr_t IndexFor(Zone* zone,
-                         const Function& function,
-                         const String& name) {
-  const Bytecode& bc = Bytecode::Handle(zone, function.bytecode());
-  const ObjectPool& pool = ObjectPool::Handle(zone, bc.object_pool());
-  const KBCInstr* pc = reinterpret_cast<const KBCInstr*>(bc.PayloadStart());
-
-  ASSERT(KernelBytecode::IsEntryOptionalOpcode(pc));
-  ASSERT(KernelBytecode::DecodeB(pc) ==
-         function.NumOptionalPositionalParameters());
-  ASSERT(KernelBytecode::DecodeC(pc) == function.NumOptionalNamedParameters());
-  pc = KernelBytecode::Next(pc);
-
-  const intptr_t num_opt_params = function.NumOptionalParameters();
-  const intptr_t num_fixed_params = function.num_fixed_parameters();
-  for (intptr_t i = 0; i < num_opt_params; i++) {
-    const KBCInstr* load_name = pc;
-    const KBCInstr* load_value = KernelBytecode::Next(load_name);
-    pc = KernelBytecode::Next(load_value);
-    ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name));
-    ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
-    if (pool.ObjectAt(KernelBytecode::DecodeE(load_name)) == name.raw()) {
-      return num_fixed_params + i;
-    }
-  }
-
-  UNREACHABLE();
-  return -1;
-}
-
-RawArray* BytecodeReaderHelper::CreateForwarderChecks(
-    const Function& function) {
-  ASSERT(function.kind() != RawFunction::kDynamicInvocationForwarder);
-  ASSERT(function.is_declared_in_bytecode());
-
-  TypeArguments& default_args = TypeArguments::Handle(Z);
-  if (function.bytecode_offset() != 0) {
-    AlternativeReadingScope alt(&reader_, function.bytecode_offset());
-
-    const intptr_t flags = reader_.ReadUInt();
-    const bool has_parameters_flags =
-        (flags & Code::kHasParameterFlagsFlag) != 0;
-    const bool has_forwarding_stub_target =
-        (flags & Code::kHasForwardingStubTargetFlag) != 0;
-    const bool has_default_function_type_args =
-        (flags & Code::kHasDefaultFunctionTypeArgsFlag) != 0;
-
-    if (has_parameters_flags) {
-      intptr_t num_params = reader_.ReadUInt();
-      ASSERT(num_params ==
-             function.NumParameters() - function.NumImplicitParameters());
-      for (intptr_t i = 0; i < num_params; ++i) {
-        reader_.ReadUInt();
-      }
-    }
-
-    if (has_forwarding_stub_target) {
-      reader_.ReadUInt();
-    }
-
-    if (has_default_function_type_args) {
-      const intptr_t index = reader_.ReadUInt();
-      const Bytecode& code = Bytecode::Handle(Z, function.bytecode());
-      const ObjectPool& pool = ObjectPool::Handle(Z, code.object_pool());
-      default_args ^= pool.ObjectAt(index);
-    }
-  }
-
-  auto& name = String::Handle(Z);
-  auto& check = ParameterTypeCheck::Handle(Z);
-  auto& checks = GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
-
-  checks.Add(function);
-  checks.Add(default_args);
-
-  const auto& type_params =
-      TypeArguments::Handle(Z, function.type_parameters());
-  if (!type_params.IsNull()) {
-    auto& type_param = TypeParameter::Handle(Z);
-    auto& bound = AbstractType::Handle(Z);
-    for (intptr_t i = 0, n = type_params.Length(); i < n; ++i) {
-      type_param ^= type_params.TypeAt(i);
-      bound = type_param.bound();
-      if (!bound.IsTopType() && !type_param.IsGenericCovariantImpl()) {
-        name = type_param.name();
-        ASSERT(type_param.IsFinalized());
-        check = ParameterTypeCheck::New();
-        check.set_param(type_param);
-        check.set_type_or_bound(bound);
-        check.set_name(name);
-        checks.Add(check);
-      }
-    }
-  }
-
-  const intptr_t num_params = function.NumParameters();
-  const intptr_t num_pos_params = function.HasOptionalNamedParameters()
-                                      ? function.num_fixed_parameters()
-                                      : num_params;
-
-  BitVector is_covariant(Z, num_params);
-  BitVector is_generic_covariant_impl(Z, num_params);
-  ReadParameterCovariance(function, &is_covariant, &is_generic_covariant_impl);
-
-  auto& type = AbstractType::Handle(Z);
-  auto& cache = SubtypeTestCache::Handle(Z);
-  const bool has_optional_parameters = function.HasOptionalParameters();
-  for (intptr_t i = function.NumImplicitParameters(); i < num_params; ++i) {
-    type = function.ParameterTypeAt(i);
-    if (!type.IsTopType() && !is_generic_covariant_impl.Contains(i) &&
-        !is_covariant.Contains(i)) {
-      name = function.ParameterNameAt(i);
-      intptr_t index;
-      if (i >= num_pos_params) {
-        // Named parameter.
-        index = IndexFor(Z, function, name);
-      } else if (has_optional_parameters) {
-        // Fixed or optional parameter.
-        index = i;
-      } else {
-        // Fixed parameter.
-        index = -kKBCParamEndSlotFromFp - num_params + i;
-      }
-      check = ParameterTypeCheck::New();
-      check.set_index(index);
-      check.set_type_or_bound(type);
-      check.set_name(name);
-      cache = SubtypeTestCache::New();
-      check.set_cache(cache);
-      checks.Add(check);
-    }
-  }
-
-  return Array::MakeFixedLength(checks);
-}
-
 void BytecodeReaderHelper::ReadClosureDeclaration(const Function& function,
                                                   intptr_t closureIndex) {
   // Closure flags, must be in sync with ClosureDeclaration constants in
@@ -2233,7 +2096,7 @@
   VMTagScope tagScope(thread, VMTag::kLoadBytecodeTagId);
 
 #if defined(SUPPORT_TIMELINE)
-  TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
+  TimelineDurationScope tds(Thread::Current(), Timeline::GetCompilerStream(),
                             "BytecodeReader::ReadFunctionBytecode");
   // This increases bytecode reading time by ~7%, so only keep it around for
   // debugging.
@@ -2267,7 +2130,7 @@
         bytecode = Object::method_extractor_bytecode().raw();
         break;
       case RawFunction::kInvokeFieldDispatcher:
-        if (Class::Handle(zone, function.Owner()).id() == kClosureCid) {
+        if (Class::Handle(function.Owner()).id() == kClosureCid) {
           bytecode = Object::invoke_closure_bytecode().raw();
         } else {
           bytecode = Object::invoke_field_bytecode().raw();
@@ -2276,36 +2139,6 @@
       case RawFunction::kNoSuchMethodDispatcher:
         bytecode = Object::nsm_dispatcher_bytecode().raw();
         break;
-      case RawFunction::kDynamicInvocationForwarder: {
-        const Function& target =
-            Function::Handle(zone, function.ForwardingTarget());
-        if (!target.HasBytecode()) {
-          // The forwarder will use the target's bytecode to handle optional
-          // parameters.
-          const Error& error =
-              Error::Handle(zone, ReadFunctionBytecode(thread, target));
-          if (!error.IsNull()) {
-            return error.raw();
-          }
-        }
-        {
-          const Script& script = Script::Handle(zone, target.script());
-          TranslationHelper translation_helper(thread);
-          translation_helper.InitFromScript(script);
-
-          ActiveClass active_class;
-          BytecodeComponentData bytecode_component(
-              Array::Handle(zone, translation_helper.GetBytecodeComponent()));
-          ASSERT(!bytecode_component.IsNull());
-          BytecodeReaderHelper bytecode_reader(
-              &translation_helper, &active_class, &bytecode_component);
-
-          const Array& checks = Array::Handle(
-              zone, bytecode_reader.CreateForwarderChecks(target));
-          function.SetForwardingChecks(checks);
-        }
-        bytecode = Object::dynamic_invocation_forwarder_bytecode().raw();
-      } break;
       default:
         break;
     }
diff --git a/runtime/vm/compiler/frontend/bytecode_reader.h b/runtime/vm/compiler/frontend/bytecode_reader.h
index 830bf95..753bff9 100644
--- a/runtime/vm/compiler/frontend/bytecode_reader.h
+++ b/runtime/vm/compiler/frontend/bytecode_reader.h
@@ -54,8 +54,6 @@
 
   void ReadCode(const Function& function, intptr_t code_offset);
 
-  RawArray* CreateForwarderChecks(const Function& function);
-
   void ReadMembers(const Class& cls,
                    intptr_t members_offset,
                    bool discard_fields);
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 0306907..2668c17 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -2234,13 +2234,7 @@
                          function.IsImplicitSetterFunction();
   const bool is_method = !function.IsStaticFunction();
 
-  Field& field = Field::ZoneHandle(Z);
-  if (function.IsDynamicInvocationForwarder()) {
-    Function& target = Function::Handle(function.ForwardingTarget());
-    field = target.accessor_field();
-  } else {
-    field = function.accessor_field();
-  }
+  Field& field = Field::ZoneHandle(Z, function.accessor_field());
 
   graph_entry_ =
       new (Z) GraphEntryInstr(*parsed_function_, Compiler::kNoOSRDeoptId);
diff --git a/runtime/vm/interpreter.cc b/runtime/vm/interpreter.cc
index 2f823c5..e188c08 100644
--- a/runtime/vm/interpreter.cc
+++ b/runtime/vm/interpreter.cc
@@ -1186,120 +1186,6 @@
   }
 #endif  // PRODUCT
 
-bool Interpreter::CopyParameters(Thread* thread,
-                                 const KBCInstr** pc,
-                                 RawObject*** FP,
-                                 RawObject*** SP,
-                                 const intptr_t num_fixed_params,
-                                 const intptr_t num_opt_pos_params,
-                                 const intptr_t num_opt_named_params) {
-  const intptr_t min_num_pos_args = num_fixed_params;
-  const intptr_t max_num_pos_args = num_fixed_params + num_opt_pos_params;
-
-  // Decode arguments descriptor.
-  const intptr_t arg_count = InterpreterHelpers::ArgDescArgCount(argdesc_);
-  const intptr_t pos_count = InterpreterHelpers::ArgDescPosCount(argdesc_);
-  const intptr_t named_count = (arg_count - pos_count);
-
-  // Check that got the right number of positional parameters.
-  if ((min_num_pos_args > pos_count) || (pos_count > max_num_pos_args)) {
-    return false;
-  }
-
-  // Copy all passed position arguments.
-  RawObject** first_arg = FrameArguments(*FP, arg_count);
-  memmove(*FP, first_arg, pos_count * kWordSize);
-
-  if (num_opt_named_params != 0) {
-    // This is a function with named parameters.
-    // Walk the list of named parameters and their
-    // default values encoded as pairs of LoadConstant instructions that
-    // follows the entry point and find matching values via arguments
-    // descriptor.
-    RawObject** argdesc_data = argdesc_->ptr()->data();
-
-    intptr_t i = 0;  // argument position
-    intptr_t j = 0;  // parameter position
-    while ((j < num_opt_named_params) && (i < named_count)) {
-      // Fetch formal parameter information: name, default value, target slot.
-      const KBCInstr* load_name = *pc;
-      const KBCInstr* load_value = KernelBytecode::Next(load_name);
-      *pc = KernelBytecode::Next(load_value);
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name));
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
-      const uint8_t reg = KernelBytecode::DecodeA(load_name);
-      ASSERT(reg == KernelBytecode::DecodeA(load_value));
-
-      RawString* name = static_cast<RawString*>(
-          LOAD_CONSTANT(KernelBytecode::DecodeE(load_name)));
-      if (name == argdesc_data[ArgumentsDescriptor::name_index(i)]) {
-        // Parameter was passed. Fetch passed value.
-        const intptr_t arg_index = Smi::Value(static_cast<RawSmi*>(
-            argdesc_data[ArgumentsDescriptor::position_index(i)]));
-        (*FP)[reg] = first_arg[arg_index];
-        ++i;  // Consume passed argument.
-      } else {
-        // Parameter was not passed. Fetch default value.
-        (*FP)[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
-      }
-      ++j;  // Next formal parameter.
-    }
-
-    // If we have unprocessed formal parameters then initialize them all
-    // using default values.
-    while (j < num_opt_named_params) {
-      const KBCInstr* load_name = *pc;
-      const KBCInstr* load_value = KernelBytecode::Next(load_name);
-      *pc = KernelBytecode::Next(load_value);
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name));
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
-      const uint8_t reg = KernelBytecode::DecodeA(load_name);
-      ASSERT(reg == KernelBytecode::DecodeA(load_value));
-
-      (*FP)[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
-      ++j;
-    }
-
-    // If we have unprocessed passed arguments that means we have mismatch
-    // between formal parameters and concrete arguments. This can only
-    // occur if the current function is a closure.
-    if (i < named_count) {
-      return false;
-    }
-
-    // SP points past copied arguments.
-    *SP = *FP + num_fixed_params + num_opt_named_params - 1;
-  } else {
-    ASSERT(num_opt_pos_params != 0);
-    if (named_count != 0) {
-      // Function can't have both named and optional positional parameters.
-      // This kind of mismatch can only occur if the current function
-      // is a closure.
-      return false;
-    }
-
-    // Process the list of default values encoded as a sequence of
-    // LoadConstant instructions after EntryOpt bytecode.
-    // Execute only those that correspond to parameters that were not passed.
-    for (intptr_t i = num_fixed_params; i < pos_count; ++i) {
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(*pc));
-      *pc = KernelBytecode::Next(*pc);
-    }
-    for (intptr_t i = pos_count; i < max_num_pos_args; ++i) {
-      const KBCInstr* load_value = *pc;
-      *pc = KernelBytecode::Next(load_value);
-      ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
-      ASSERT(KernelBytecode::DecodeA(load_value) == i);
-      (*FP)[i] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
-    }
-
-    // SP points past the last copied parameter.
-    *SP = *FP + max_num_pos_args - 1;
-  }
-
-  return true;
-}
-
 bool Interpreter::AssertAssignable(Thread* thread,
                                    const KBCInstr* pc,
                                    RawObject** FP,
@@ -1765,11 +1651,114 @@
 
   {
     BYTECODE(EntryOptional, A_B_C);
-    if (CopyParameters(thread, &pc, &FP, &SP, rA, rB, rC)) {
-      DISPATCH();
-    } else {
+    const intptr_t num_fixed_params = rA;
+    const intptr_t num_opt_pos_params = rB;
+    const intptr_t num_opt_named_params = rC;
+    const intptr_t min_num_pos_args = num_fixed_params;
+    const intptr_t max_num_pos_args = num_fixed_params + num_opt_pos_params;
+
+    // Decode arguments descriptor.
+    const intptr_t arg_count = InterpreterHelpers::ArgDescArgCount(argdesc_);
+    const intptr_t pos_count = InterpreterHelpers::ArgDescPosCount(argdesc_);
+    const intptr_t named_count = (arg_count - pos_count);
+
+    // Check that got the right number of positional parameters.
+    if ((min_num_pos_args > pos_count) || (pos_count > max_num_pos_args)) {
       goto NoSuchMethodFromPrologue;
     }
+
+    // Copy all passed position arguments.
+    RawObject** first_arg = FrameArguments(FP, arg_count);
+    memmove(FP, first_arg, pos_count * kWordSize);
+
+    if (num_opt_named_params != 0) {
+      // This is a function with named parameters.
+      // Walk the list of named parameters and their
+      // default values encoded as pairs of LoadConstant instructions that
+      // follows the entry point and find matching values via arguments
+      // descriptor.
+      RawObject** argdesc_data = argdesc_->ptr()->data();
+
+      intptr_t i = 0;  // argument position
+      intptr_t j = 0;  // parameter position
+      while ((j < num_opt_named_params) && (i < named_count)) {
+        // Fetch formal parameter information: name, default value, target slot.
+        const KBCInstr* load_name = pc;
+        const KBCInstr* load_value = KernelBytecode::Next(load_name);
+        pc = KernelBytecode::Next(load_value);
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name));
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
+        const uint8_t reg = KernelBytecode::DecodeA(load_name);
+        ASSERT(reg == KernelBytecode::DecodeA(load_value));
+
+        RawString* name = static_cast<RawString*>(
+            LOAD_CONSTANT(KernelBytecode::DecodeE(load_name)));
+        if (name == argdesc_data[ArgumentsDescriptor::name_index(i)]) {
+          // Parameter was passed. Fetch passed value.
+          const intptr_t arg_index = Smi::Value(static_cast<RawSmi*>(
+              argdesc_data[ArgumentsDescriptor::position_index(i)]));
+          FP[reg] = first_arg[arg_index];
+          ++i;  // Consume passed argument.
+        } else {
+          // Parameter was not passed. Fetch default value.
+          FP[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
+        }
+        ++j;  // Next formal parameter.
+      }
+
+      // If we have unprocessed formal parameters then initialize them all
+      // using default values.
+      while (j < num_opt_named_params) {
+        const KBCInstr* load_name = pc;
+        const KBCInstr* load_value = KernelBytecode::Next(load_name);
+        pc = KernelBytecode::Next(load_value);
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name));
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
+        const uint8_t reg = KernelBytecode::DecodeA(load_name);
+        ASSERT(reg == KernelBytecode::DecodeA(load_value));
+
+        FP[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
+        ++j;
+      }
+
+      // If we have unprocessed passed arguments that means we have mismatch
+      // between formal parameters and concrete arguments. This can only
+      // occur if the current function is a closure.
+      if (i < named_count) {
+        goto NoSuchMethodFromPrologue;
+      }
+
+      // SP points past copied arguments.
+      SP = FP + num_fixed_params + num_opt_named_params - 1;
+    } else {
+      ASSERT(num_opt_pos_params != 0);
+      if (named_count != 0) {
+        // Function can't have both named and optional positional parameters.
+        // This kind of mismatch can only occur if the current function
+        // is a closure.
+        goto NoSuchMethodFromPrologue;
+      }
+
+      // Process the list of default values encoded as a sequence of
+      // LoadConstant instructions after EntryOpt bytecode.
+      // Execute only those that correspond to parameters that were not passed.
+      for (intptr_t i = num_fixed_params; i < pos_count; ++i) {
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(pc));
+        pc = KernelBytecode::Next(pc);
+      }
+      for (intptr_t i = pos_count; i < max_num_pos_args; ++i) {
+        const KBCInstr* load_value = pc;
+        pc = KernelBytecode::Next(load_value);
+        ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value));
+        ASSERT(KernelBytecode::DecodeA(load_value) == i);
+        FP[i] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value));
+      }
+
+      // SP points past the last copied parameter.
+      SP = FP + max_num_pos_args - 1;
+    }
+
+    DISPATCH();
   }
 
   {
@@ -3480,101 +3469,8 @@
     RawFunction* function = FrameFunction(FP);
     ASSERT(Function::kind(function) ==
            RawFunction::kDynamicInvocationForwarder);
-
-    BUMP_USAGE_COUNTER_ON_ENTRY(function);
-
-    RawArray* checks = Array::RawCast(function->ptr()->data_);
-    RawFunction* target = Function::RawCast(checks->ptr()->data()[0]);
-    ASSERT(Function::kind(target) != RawFunction::kDynamicInvocationForwarder);
-    RawBytecode* target_bytecode = target->ptr()->bytecode_;
-    ASSERT(target_bytecode != Bytecode::null());
-    ASSERT(target_bytecode->IsBytecode());
-
-    const KBCInstr* pc2 = reinterpret_cast<const KBCInstr*>(
-        target_bytecode->ptr()->instructions_);
-    if (KernelBytecode::IsEntryOptionalOpcode(pc2)) {
-      pp_ = target_bytecode->ptr()->object_pool_;
-      uint32_t rA, rB, rC;
-      rA = KernelBytecode::DecodeA(pc2);
-      rB = KernelBytecode::DecodeB(pc2);
-      rC = KernelBytecode::DecodeC(pc2);
-      pc2 = KernelBytecode::Next(pc2);
-      if (!CopyParameters(thread, &pc2, &FP, &SP, rA, rB, rC)) {
-        goto NoSuchMethodFromPrologue;
-      }
-    }
-
-    intptr_t len = Smi::Value(checks->ptr()->length_);
-    SP[1] = checks;
-    SP[2] = argdesc_;
-
-    const intptr_t type_args_len =
-        InterpreterHelpers::ArgDescTypeArgsLen(argdesc_);
-    const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0;
-    const intptr_t argc =
-        InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx;
-
-    RawInstance* receiver =
-        Instance::RawCast(FrameArguments(FP, argc)[receiver_idx]);
-    SP[5] = InterpreterHelpers::GetTypeArguments(thread, receiver);
-
-    if (type_args_len > 0) {
-      SP[6] = FrameArguments(FP, argc)[0];
-    } else {
-      SP[6] = TypeArguments::RawCast(checks->ptr()->data()[1]);
-      if (SP[5] != null_value && SP[6] != null_value) {
-        SP[7] = SP[6];       // type_arguments
-        SP[8] = SP[5];       // instantiator_type_args
-        SP[9] = null_value;  // function_type_args
-        Exit(thread, FP, SP + 10, pc);
-        NativeArguments args(thread, 3, SP + 7, SP + 7);
-        INVOKE_RUNTIME(DRT_InstantiateTypeArguments, args);
-        SP[6] = SP[7];
-      }
-    }
-
-    for (intptr_t i = 2; i < len; i++) {
-      RawParameterTypeCheck* check =
-          ParameterTypeCheck::RawCast(checks->ptr()->data()[i]);
-
-      if (LIKELY(check->ptr()->index_ != 0)) {
-        ASSERT(&FP[check->ptr()->index_] <= SP);
-        SP[3] = Instance::RawCast(FP[check->ptr()->index_]);
-        if (SP[3] == null_value) {
-          continue;  // Not handled by AssertAssignable for some reason...
-        }
-        SP[4] = check->ptr()->type_or_bound_;
-        // SP[5]: Instantiator type args.
-        // SP[6]: Function type args.
-        SP[7] = check->ptr()->name_;
-        if (!AssertAssignable(thread, pc, FP, SP, SP + 3,
-                              check->ptr()->cache_)) {
-          HANDLE_EXCEPTION;
-        }
-      } else {
-        SP[3] = 0;
-        SP[4] = 0;
-        // SP[5]: Instantiator type args.
-        // SP[6]: Function type args.
-        SP[7] = check->ptr()->param_;
-        SP[8] = check->ptr()->type_or_bound_;
-        SP[9] = check->ptr()->name_;
-        SP[10] = 0;
-        Exit(thread, FP, SP + 11, pc);
-        NativeArguments native_args(thread, 5, SP + 5, SP + 10);
-        INVOKE_RUNTIME(DRT_SubtypeCheck, native_args);
-      }
-
-      checks = Array::RawCast(SP[1]);  // Reload after runtime call.
-    }
-
-    target = Function::RawCast(checks->ptr()->data()[0]);
-    argdesc_ = Array::RawCast(SP[2]);
-
-    SP = FP - 1;  // Unmarshall optional parameters.
-
-    SP[1] = target;
-    goto TailCallSP1;
+    UNIMPLEMENTED();
+    DISPATCH();
   }
 
   {
diff --git a/runtime/vm/interpreter.h b/runtime/vm/interpreter.h
index a8e393f..a47eecc 100644
--- a/runtime/vm/interpreter.h
+++ b/runtime/vm/interpreter.h
@@ -209,14 +209,6 @@
                      RawObject*** SP,
                      bool optimized);
 
-  bool CopyParameters(Thread* thread,
-                      const KBCInstr** pc,
-                      RawObject*** FP,
-                      RawObject*** SP,
-                      const intptr_t num_fixed_params,
-                      const intptr_t num_opt_pos_params,
-                      const intptr_t num_opt_named_params);
-
   bool AssertAssignable(Thread* thread,
                         const KBCInstr* pc,
                         RawObject** FP,
diff --git a/runtime/vm/kernel.cc b/runtime/vm/kernel.cc
index b16d1b3..946135e 100644
--- a/runtime/vm/kernel.cc
+++ b/runtime/vm/kernel.cc
@@ -11,7 +11,6 @@
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"  // For Parser::kParameter* constants.
-#include "vm/stack_frame.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
diff --git a/runtime/vm/kernel.h b/runtime/vm/kernel.h
index 32f975f..4e66b89 100644
--- a/runtime/vm/kernel.h
+++ b/runtime/vm/kernel.h
@@ -208,11 +208,6 @@
 // as such function already checks all of its parameters.
 bool NeedsDynamicInvocationForwarder(const Function& function);
 
-// Returns a list of ParameterTypeChecks needed by a dynamic invocation
-// forwarder that targets [function]. Indices in these checks correspond to
-// bytecode frame indices.
-RawArray* CollectDynamicInvocationChecks(const Function& function);
-
 ProcedureAttributesMetadata ProcedureAttributesOf(const Function& function,
                                                   Zone* zone);
 
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 6066a17..f914e28 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -153,8 +153,6 @@
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::dyncalltypecheck_class_ =
-    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::singletargetcache_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unlinkedcall_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ -650,9 +648,6 @@
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
-  cls = Class::New<ParameterTypeCheck>();
-  dyncalltypecheck_class_ = cls.raw();
-
   cls = Class::New<SingleTargetCache>();
   singletargetcache_class_ = cls.raw();
 
@@ -912,9 +907,6 @@
   *nsm_dispatcher_bytecode_ = CreateVMInternalBytecode(
       KernelBytecode::kVMInternal_NoSuchMethodDispatcher);
 
-  *dynamic_invocation_forwarder_bytecode_ = CreateVMInternalBytecode(
-      KernelBytecode::kVMInternal_ForwardDynamicInvocation);
-
   // Some thread fields need to be reinitialized as null constants have not been
   // initialized until now.
   Thread* thr = Thread::Current();
@@ -986,8 +978,6 @@
   ASSERT(invoke_field_bytecode_->IsBytecode());
   ASSERT(!nsm_dispatcher_bytecode_->IsSmi());
   ASSERT(nsm_dispatcher_bytecode_->IsBytecode());
-  ASSERT(!dynamic_invocation_forwarder_bytecode_->IsSmi());
-  ASSERT(dynamic_invocation_forwarder_bytecode_->IsBytecode());
 }
 
 void Object::FinishInit(Isolate* isolate) {
@@ -1031,7 +1021,6 @@
   exception_handlers_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-  dyncalltypecheck_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   singletargetcache_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   unlinkedcall_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   icdata_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ -1131,7 +1120,6 @@
   SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
   SET_CLASS_NAME(context, Context);
   SET_CLASS_NAME(context_scope, ContextScope);
-  SET_CLASS_NAME(dyncalltypecheck, ParameterTypeCheck);
   SET_CLASS_NAME(singletargetcache, SingleTargetCache);
   SET_CLASS_NAME(unlinkedcall, UnlinkedCall);
   SET_CLASS_NAME(icdata, ICData);
@@ -3070,10 +3058,6 @@
 
   forwarder.InheritBinaryDeclarationFrom(*this);
 
-  const Array& checks = Array::Handle(zone, Array::New(1));
-  checks.SetAt(0, *this);
-  forwarder.SetForwardingChecks(checks);
-
   return forwarder.raw();
 }
 
@@ -3909,8 +3893,6 @@
       return Symbols::Context().raw();
     case kContextScopeCid:
       return Symbols::ContextScope().raw();
-    case kParameterTypeCheckCid:
-      return Symbols::ParameterTypeCheck().raw();
     case kSingleTargetCacheCid:
       return Symbols::SingleTargetCache().raw();
     case kICDataCid:
@@ -5673,7 +5655,6 @@
   }
   switch (kind()) {
     case RawFunction::kDynamicInvocationForwarder:
-      return is_declared_in_bytecode();
     case RawFunction::kImplicitClosureFunction:
     case RawFunction::kIrregexpFunction:
     case RawFunction::kFfiTrampoline:
@@ -5896,7 +5877,8 @@
   ASSERT(kind() == RawFunction::kImplicitGetter ||
          kind() == RawFunction::kImplicitSetter ||
          kind() == RawFunction::kImplicitStaticGetter ||
-         kind() == RawFunction::kStaticFieldInitializer);
+         kind() == RawFunction::kStaticFieldInitializer ||
+         kind() == RawFunction::kDynamicInvocationForwarder);
   return Field::RawCast(raw_ptr()->data_);
 }
 
@@ -6235,20 +6217,6 @@
   RedirectionData::Cast(obj).set_target(target);
 }
 
-RawFunction* Function::ForwardingTarget() const {
-  ASSERT(kind() == RawFunction::kDynamicInvocationForwarder);
-  Array& checks = Array::Handle();
-  checks ^= raw_ptr()->data_;
-  return Function::RawCast(checks.At(0));
-}
-
-void Function::SetForwardingChecks(const Array& checks) const {
-  ASSERT(kind() == RawFunction::kDynamicInvocationForwarder);
-  ASSERT(checks.Length() >= 1);
-  ASSERT(Object::Handle(checks.At(0)).IsFunction());
-  set_data(checks);
-}
-
 // This field is heavily overloaded:
 //   eval function:           Script expression source
 //   kernel eval function:    Array[0] = Script
@@ -6270,9 +6238,6 @@
 //                            Array[1] = Function implicit closure function
 //   regular function:        Function for implicit closure function
 //   ffi trampoline function: FfiTrampolineData  (Dart->C)
-//   dyn inv forwarder:       Array[0] = Function target
-//                            Array[1] = TypeArguments default type args
-//                            Array[i] = ParameterTypeCheck
 void Function::set_data(const Object& value) const {
   StorePointer(&raw_ptr()->data_, value.raw());
 }
@@ -13221,43 +13186,6 @@
 #undef FORMAT2
 }
 
-void ParameterTypeCheck::set_type_or_bound(const AbstractType& value) const {
-  StorePointer(&raw_ptr()->type_or_bound_, value.raw());
-}
-
-void ParameterTypeCheck::set_param(const AbstractType& value) const {
-  StorePointer(&raw_ptr()->param_, value.raw());
-}
-
-void ParameterTypeCheck::set_name(const String& value) const {
-  StorePointer(&raw_ptr()->name_, value.raw());
-}
-
-void ParameterTypeCheck::set_cache(const SubtypeTestCache& value) const {
-  StorePointer(&raw_ptr()->cache_, value.raw());
-}
-
-const char* ParameterTypeCheck::ToCString() const {
-  Zone* zone = Thread::Current()->zone();
-  return zone->PrintToString("ParameterTypeCheck(%" Pd " %s %s %s)", index(),
-                             Object::Handle(zone, param()).ToCString(),
-                             Object::Handle(zone, type_or_bound()).ToCString(),
-                             Object::Handle(zone, name()).ToCString());
-}
-
-RawParameterTypeCheck* ParameterTypeCheck::New() {
-  ParameterTypeCheck& result = ParameterTypeCheck::Handle();
-  {
-    RawObject* raw =
-        Object::Allocate(ParameterTypeCheck::kClassId,
-                         ParameterTypeCheck::InstanceSize(), Heap::kOld);
-    NoSafepointScope no_safepoint;
-    result ^= raw;
-  }
-  result.set_index(0);
-  return result.raw();
-}
-
 void SingleTargetCache::set_target(const Code& value) const {
   StorePointer(&raw_ptr()->target_, value.raw());
 }
@@ -13324,14 +13252,14 @@
 }
 
 const char* ICData::ToCString() const {
-  Zone* zone = Thread::Current()->zone();
-  const String& name = String::Handle(zone, target_name());
+  const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
   const intptr_t num_checks = NumberOfChecks();
   const intptr_t type_args_len = TypeArgsLen();
-  return zone->PrintToString(
-      "ICData(%s num-args: %" Pd " num-checks: %" Pd " type-args-len: %" Pd ")",
-      name.ToCString(), num_args, num_checks, type_args_len);
+  return OS::SCreate(Thread::Current()->zone(),
+                     "ICData target:'%s' num-args: %" Pd " num-checks: %" Pd
+                     " type-args-len: %" Pd "",
+                     name.ToCString(), num_args, num_checks, type_args_len);
 }
 
 RawFunction* ICData::Owner() const {
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 82b27a0..33261da 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -403,7 +403,6 @@
   V(Bytecode, invoke_closure_bytecode)                                         \
   V(Bytecode, invoke_field_bytecode)                                           \
   V(Bytecode, nsm_dispatcher_bytecode)                                         \
-  V(Bytecode, dynamic_invocation_forwarder_bytecode)                           \
   V(Instance, sentinel)                                                        \
   V(Instance, transition_sentinel)                                             \
   V(Instance, unknown_constant)                                                \
@@ -469,7 +468,6 @@
     return unhandled_exception_class_;
   }
   static RawClass* unwind_error_class() { return unwind_error_class_; }
-  static RawClass* dyncalltypecheck_class() { return dyncalltypecheck_class_; }
   static RawClass* singletargetcache_class() {
     return singletargetcache_class_;
   }
@@ -707,7 +705,6 @@
   static RawClass* deopt_info_class_;          // Class of DeoptInfo.
   static RawClass* context_class_;        // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
-  static RawClass* dyncalltypecheck_class_;     // Class of ParameterTypeCheck.
   static RawClass* singletargetcache_class_;    // Class of SingleTargetCache.
   static RawClass* unlinkedcall_class_;         // Class of UnlinkedCall.
   static RawClass* icdata_class_;               // Class of ICData.
@@ -1494,41 +1491,6 @@
   friend class Class;
 };
 
-class ParameterTypeCheck : public Object {
- public:
-  // The FP-relative index of the parameter in a bytecode frame (after optional
-  // parameter marshalling) whose assignability needs to be checked, or 0 if
-  // this is a type parameter check.
-  intptr_t index() const { return raw_ptr()->index_; }
-  void set_index(intptr_t i) const { StoreNonPointer(&raw_ptr()->index_, i); }
-
-  // The type parameter to whose bound needs to be checked, or null if this is
-  // an ordinary parameter check.
-  RawAbstractType* param() const { return raw_ptr()->param_; }
-  void set_param(const AbstractType& t) const;
-
-  // FP[index] assignable to type, OR param is subtype of bound.
-  RawAbstractType* type_or_bound() const { return raw_ptr()->type_or_bound_; }
-  void set_type_or_bound(const AbstractType& t) const;
-
-  // The parameter or type parameter's name to use in an error message.
-  RawString* name() const { return raw_ptr()->name_; }
-  void set_name(const String& n) const;
-
-  RawSubtypeTestCache* cache() const { return raw_ptr()->cache_; }
-  void set_cache(const SubtypeTestCache& c) const;
-
-  static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawParameterTypeCheck));
-  }
-
-  static RawParameterTypeCheck* New();
-
- private:
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(ParameterTypeCheck, Object);
-  friend class Class;
-};
-
 class SingleTargetCache : public Object {
  public:
   RawCode* target() const { return raw_ptr()->target_; }
@@ -2287,9 +2249,6 @@
   RawFunction* RedirectionTarget() const;
   void SetRedirectionTarget(const Function& target) const;
 
-  RawFunction* ForwardingTarget() const;
-  void SetForwardingChecks(const Array& checks) const;
-
   RawFunction::Kind kind() const {
     return KindBits::decode(raw_ptr()->kind_tag_);
   }
@@ -3043,6 +3002,7 @@
   void set_num_optional_parameters(intptr_t value) const;  // Encoded value.
   void set_kind_tag(uint32_t value) const;
   void set_data(const Object& value) const;
+
   static RawFunction* New(Heap::Space space = Heap::kOld);
 
   RawString* QualifiedName(NameVisibility name_visibility) const;
diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc
index e95e14e..3616d4e 100644
--- a/runtime/vm/object_service.cc
+++ b/runtime/vm/object_service.cc
@@ -729,10 +729,6 @@
   Object::PrintJSONImpl(stream, ref);
 }
 
-void ParameterTypeCheck::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  Object::PrintJSONImpl(stream, ref);
-}
-
 void SingleTargetCache::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   AddCommonObjectProperties(&jsobj, "Object", ref);
diff --git a/runtime/vm/raw_object.cc b/runtime/vm/raw_object.cc
index 24a79f8..0658a6d 100644
--- a/runtime/vm/raw_object.cc
+++ b/runtime/vm/raw_object.cc
@@ -438,7 +438,6 @@
 REGULAR_VISITOR(Library)
 REGULAR_VISITOR(LibraryPrefix)
 REGULAR_VISITOR(Namespace)
-REGULAR_VISITOR(ParameterTypeCheck)
 REGULAR_VISITOR(SingleTargetCache)
 REGULAR_VISITOR(UnlinkedCall)
 REGULAR_VISITOR(ICData)
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index 91ff01e..1028af1 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -1705,18 +1705,6 @@
   friend class SnapshotReader;
 };
 
-class RawParameterTypeCheck : public RawObject {
-  RAW_HEAP_OBJECT_IMPLEMENTATION(ParameterTypeCheck);
-  intptr_t index_;
-  VISIT_FROM(RawObject*, param_);
-  RawAbstractType* param_;
-  RawAbstractType* type_or_bound_;
-  RawString* name_;
-  RawSubtypeTestCache* cache_;
-  VISIT_TO(RawObject*, cache_);
-  RawObject** to_snapshot(Snapshot::Kind kind) { return to(); }
-};
-
 class RawSingleTargetCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(SingleTargetCache);
   VISIT_FROM(RawObject*, target_);
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index 22a7016..d734dbb 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -71,6 +71,22 @@
   }
 }
 
+RawAbstractType* AbstractType::ReadFrom(SnapshotReader* reader,
+                                        intptr_t object_id,
+                                        intptr_t tags,
+                                        Snapshot::Kind kind,
+                                        bool as_reference) {
+  UNREACHABLE();  // AbstractType is an abstract class.
+  return NULL;
+}
+
+void RawAbstractType::WriteTo(SnapshotWriter* writer,
+                              intptr_t object_id,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  UNREACHABLE();  // AbstractType is an abstract class.
+}
+
 RawType* Type::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
@@ -348,6 +364,22 @@
   }
 }
 
+RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind,
+                                    bool as_reference) {
+  UNREACHABLE();
+  return PatchClass::null();
+}
+
+void RawPatchClass::WriteTo(SnapshotWriter* writer,
+                            intptr_t object_id,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  UNREACHABLE();
+}
+
 RawClosure* Closure::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
@@ -375,6 +407,326 @@
   UNREACHABLE();
 }
 
+RawClosureData* ClosureData::ReadFrom(SnapshotReader* reader,
+                                      intptr_t object_id,
+                                      intptr_t tags,
+                                      Snapshot::Kind kind,
+                                      bool as_reference) {
+  UNREACHABLE();
+  return ClosureData::null();
+}
+
+void RawClosureData::WriteTo(SnapshotWriter* writer,
+                             intptr_t object_id,
+                             Snapshot::Kind kind,
+                             bool as_reference) {
+  UNREACHABLE();
+}
+
+RawSignatureData* SignatureData::ReadFrom(SnapshotReader* reader,
+                                          intptr_t object_id,
+                                          intptr_t tags,
+                                          Snapshot::Kind kind,
+                                          bool as_reference) {
+  UNREACHABLE();
+  return SignatureData::null();
+}
+
+void RawSignatureData::WriteTo(SnapshotWriter* writer,
+                               intptr_t object_id,
+                               Snapshot::Kind kind,
+                               bool as_reference) {
+  UNREACHABLE();
+}
+
+RawRedirectionData* RedirectionData::ReadFrom(SnapshotReader* reader,
+                                              intptr_t object_id,
+                                              intptr_t tags,
+                                              Snapshot::Kind kind,
+                                              bool as_reference) {
+  UNREACHABLE();
+  return RedirectionData::null();
+}
+
+void RawRedirectionData::WriteTo(SnapshotWriter* writer,
+                                 intptr_t object_id,
+                                 Snapshot::Kind kind,
+                                 bool as_reference) {
+  UNREACHABLE();
+}
+
+RawFfiTrampolineData* FfiTrampolineData::ReadFrom(SnapshotReader* reader,
+                                                  intptr_t object_id,
+                                                  intptr_t tags,
+                                                  Snapshot::Kind kind,
+                                                  bool as_reference) {
+  UNREACHABLE();
+  return FfiTrampolineData::null();
+}
+
+void RawFfiTrampolineData::WriteTo(SnapshotWriter* writer,
+                                   intptr_t object_id,
+                                   Snapshot::Kind kind,
+                                   bool as_reference) {
+  UNREACHABLE();
+}
+
+RawFunction* Function::ReadFrom(SnapshotReader* reader,
+                                intptr_t object_id,
+                                intptr_t tags,
+                                Snapshot::Kind kind,
+                                bool as_reference) {
+  UNREACHABLE();
+  return Function::null();
+}
+
+void RawFunction::WriteTo(SnapshotWriter* writer,
+                          intptr_t object_id,
+                          Snapshot::Kind kind,
+                          bool as_reference) {
+  UNREACHABLE();
+}
+
+RawField* Field::ReadFrom(SnapshotReader* reader,
+                          intptr_t object_id,
+                          intptr_t tags,
+                          Snapshot::Kind kind,
+                          bool as_reference) {
+  UNREACHABLE();
+  return Field::null();
+}
+
+void RawField::WriteTo(SnapshotWriter* writer,
+                       intptr_t object_id,
+                       Snapshot::Kind kind,
+                       bool as_reference) {
+  UNREACHABLE();
+}
+
+RawScript* Script::ReadFrom(SnapshotReader* reader,
+                            intptr_t object_id,
+                            intptr_t tags,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  UNREACHABLE();
+  return Script::null();
+}
+
+void RawScript::WriteTo(SnapshotWriter* writer,
+                        intptr_t object_id,
+                        Snapshot::Kind kind,
+                        bool as_reference) {
+  UNREACHABLE();
+}
+
+RawLibrary* Library::ReadFrom(SnapshotReader* reader,
+                              intptr_t object_id,
+                              intptr_t tags,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  UNREACHABLE();
+  return Library::null();
+}
+
+void RawLibrary::WriteTo(SnapshotWriter* writer,
+                         intptr_t object_id,
+                         Snapshot::Kind kind,
+                         bool as_reference) {
+  UNREACHABLE();
+}
+
+RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
+                                          intptr_t object_id,
+                                          intptr_t tags,
+                                          Snapshot::Kind kind,
+                                          bool as_reference) {
+  UNREACHABLE();
+  return LibraryPrefix::null();
+}
+
+void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
+                               intptr_t object_id,
+                               Snapshot::Kind kind,
+                               bool as_reference) {
+  UNREACHABLE();
+}
+
+RawNamespace* Namespace::ReadFrom(SnapshotReader* reader,
+                                  intptr_t object_id,
+                                  intptr_t tags,
+                                  Snapshot::Kind kind,
+                                  bool as_reference) {
+  UNREACHABLE();
+  return Namespace::null();
+}
+
+void RawNamespace::WriteTo(SnapshotWriter* writer,
+                           intptr_t object_id,
+                           Snapshot::Kind kind,
+                           bool as_reference) {
+  UNREACHABLE();
+}
+
+RawKernelProgramInfo* KernelProgramInfo::ReadFrom(SnapshotReader* reader,
+                                                  intptr_t object_id,
+                                                  intptr_t tags,
+                                                  Snapshot::Kind kind,
+                                                  bool as_reference) {
+  UNREACHABLE();
+  return KernelProgramInfo::null();
+}
+
+void RawKernelProgramInfo::WriteTo(SnapshotWriter* writer,
+                                   intptr_t object_id,
+                                   Snapshot::Kind kind,
+                                   bool as_reference) {
+  UNREACHABLE();
+}
+
+RawCode* Code::ReadFrom(SnapshotReader* reader,
+                        intptr_t object_id,
+                        intptr_t tags,
+                        Snapshot::Kind kind,
+                        bool as_reference) {
+  UNREACHABLE();
+  return Code::null();
+}
+
+void RawCode::WriteTo(SnapshotWriter* writer,
+                      intptr_t object_id,
+                      Snapshot::Kind kind,
+                      bool as_reference) {
+  UNREACHABLE();
+}
+
+RawBytecode* Bytecode::ReadFrom(SnapshotReader* reader,
+                                intptr_t object_id,
+                                intptr_t tags,
+                                Snapshot::Kind kind,
+                                bool as_reference) {
+  UNREACHABLE();
+  return Bytecode::null();
+}
+
+void RawBytecode::WriteTo(SnapshotWriter* writer,
+                          intptr_t object_id,
+                          Snapshot::Kind kind,
+                          bool as_reference) {
+  UNREACHABLE();
+}
+
+RawInstructions* Instructions::ReadFrom(SnapshotReader* reader,
+                                        intptr_t object_id,
+                                        intptr_t tags,
+                                        Snapshot::Kind kind,
+                                        bool as_reference) {
+  UNREACHABLE();
+  return Instructions::null();
+}
+
+void RawInstructions::WriteTo(SnapshotWriter* writer,
+                              intptr_t object_id,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  UNREACHABLE();
+}
+
+RawObjectPool* ObjectPool::ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind,
+                                    bool as_reference) {
+  UNREACHABLE();
+  return ObjectPool::null();
+}
+
+void RawObjectPool::WriteTo(SnapshotWriter* writer,
+                            intptr_t object_id,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  UNREACHABLE();
+}
+
+RawPcDescriptors* PcDescriptors::ReadFrom(SnapshotReader* reader,
+                                          intptr_t object_id,
+                                          intptr_t tags,
+                                          Snapshot::Kind kind,
+                                          bool as_reference) {
+  UNREACHABLE();
+  return PcDescriptors::null();
+}
+
+void RawPcDescriptors::WriteTo(SnapshotWriter* writer,
+                               intptr_t object_id,
+                               Snapshot::Kind kind,
+                               bool as_reference) {
+  UNREACHABLE();
+}
+
+RawCodeSourceMap* CodeSourceMap::ReadFrom(SnapshotReader* reader,
+                                          intptr_t object_id,
+                                          intptr_t tags,
+                                          Snapshot::Kind kind,
+                                          bool as_reference) {
+  UNREACHABLE();
+  return CodeSourceMap::null();
+}
+
+void RawCodeSourceMap::WriteTo(SnapshotWriter* writer,
+                               intptr_t object_id,
+                               Snapshot::Kind kind,
+                               bool as_reference) {
+  UNREACHABLE();
+}
+
+RawStackMap* StackMap::ReadFrom(SnapshotReader* reader,
+                                intptr_t object_id,
+                                intptr_t tags,
+                                Snapshot::Kind kind,
+                                bool as_reference) {
+  UNREACHABLE();
+  return StackMap::null();
+}
+
+void RawStackMap::WriteTo(SnapshotWriter* writer,
+                          intptr_t object_id,
+                          Snapshot::Kind kind,
+                          bool as_reference) {
+  UNREACHABLE();
+}
+
+RawLocalVarDescriptors* LocalVarDescriptors::ReadFrom(SnapshotReader* reader,
+                                                      intptr_t object_id,
+                                                      intptr_t tags,
+                                                      Snapshot::Kind kind,
+                                                      bool as_reference) {
+  UNREACHABLE();
+  return LocalVarDescriptors::null();
+}
+
+void RawLocalVarDescriptors::WriteTo(SnapshotWriter* writer,
+                                     intptr_t object_id,
+                                     Snapshot::Kind kind,
+                                     bool as_reference) {
+  UNREACHABLE();
+}
+
+RawExceptionHandlers* ExceptionHandlers::ReadFrom(SnapshotReader* reader,
+                                                  intptr_t object_id,
+                                                  intptr_t tags,
+                                                  Snapshot::Kind kind,
+                                                  bool as_reference) {
+  UNREACHABLE();
+  return ExceptionHandlers::null();
+}
+
+void RawExceptionHandlers::WriteTo(SnapshotWriter* writer,
+                                   intptr_t object_id,
+                                   Snapshot::Kind kind,
+                                   bool as_reference) {
+  UNREACHABLE();
+}
+
 RawContext* Context::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
@@ -484,72 +836,101 @@
   UNREACHABLE();
 }
 
-#define MESSAGE_SNAPSHOT_UNREACHABLE(type)                                     \
-  Raw##type* type::ReadFrom(SnapshotReader* reader, intptr_t object_id,        \
-                            intptr_t tags, Snapshot::Kind kind,                \
-                            bool as_reference) {                               \
-    UNREACHABLE();                                                             \
-    return type::null();                                                       \
-  }                                                                            \
-  void Raw##type::WriteTo(SnapshotWriter* writer, intptr_t object_id,          \
-                          Snapshot::Kind kind, bool as_reference) {            \
-    UNREACHABLE();                                                             \
-  }
+RawSingleTargetCache* SingleTargetCache::ReadFrom(SnapshotReader* reader,
+                                                  intptr_t object_id,
+                                                  intptr_t tags,
+                                                  Snapshot::Kind kind,
+                                                  bool as_reference) {
+  UNREACHABLE();
+  return SingleTargetCache::null();
+}
 
-#define MESSAGE_SNAPSHOT_ILLEGAL(type)                                         \
-  Raw##type* type::ReadFrom(SnapshotReader* reader, intptr_t object_id,        \
-                            intptr_t tags, Snapshot::Kind kind,                \
-                            bool as_reference) {                               \
-    UNREACHABLE();                                                             \
-    return type::null();                                                       \
-  }                                                                            \
-  void Raw##type::WriteTo(SnapshotWriter* writer, intptr_t object_id,          \
-                          Snapshot::Kind kind, bool as_reference) {            \
-    writer->SetWriteException(Exceptions::kArgument,                           \
-                              "Illegal argument in isolate message"            \
-                              " : (object is a " #type ")");                   \
-  }
+void RawSingleTargetCache::WriteTo(SnapshotWriter* writer,
+                                   intptr_t object_id,
+                                   Snapshot::Kind kind,
+                                   bool as_reference) {
+  UNREACHABLE();
+}
 
-MESSAGE_SNAPSHOT_UNREACHABLE(AbstractType);
-MESSAGE_SNAPSHOT_UNREACHABLE(Bool);
-MESSAGE_SNAPSHOT_UNREACHABLE(Bytecode);
-MESSAGE_SNAPSHOT_UNREACHABLE(ClosureData);
-MESSAGE_SNAPSHOT_UNREACHABLE(Code);
-MESSAGE_SNAPSHOT_UNREACHABLE(CodeSourceMap);
-MESSAGE_SNAPSHOT_UNREACHABLE(Error);
-MESSAGE_SNAPSHOT_UNREACHABLE(ExceptionHandlers);
-MESSAGE_SNAPSHOT_UNREACHABLE(FfiTrampolineData);
-MESSAGE_SNAPSHOT_UNREACHABLE(Field);
-MESSAGE_SNAPSHOT_UNREACHABLE(Function);
-MESSAGE_SNAPSHOT_UNREACHABLE(ICData);
-MESSAGE_SNAPSHOT_UNREACHABLE(Instructions);
-MESSAGE_SNAPSHOT_UNREACHABLE(KernelProgramInfo);
-MESSAGE_SNAPSHOT_UNREACHABLE(Library);
-MESSAGE_SNAPSHOT_UNREACHABLE(LibraryPrefix);
-MESSAGE_SNAPSHOT_UNREACHABLE(LocalVarDescriptors);
-MESSAGE_SNAPSHOT_UNREACHABLE(MegamorphicCache);
-MESSAGE_SNAPSHOT_UNREACHABLE(Namespace);
-MESSAGE_SNAPSHOT_UNREACHABLE(ObjectPool);
-MESSAGE_SNAPSHOT_UNREACHABLE(ParameterTypeCheck);
-MESSAGE_SNAPSHOT_UNREACHABLE(PatchClass);
-MESSAGE_SNAPSHOT_UNREACHABLE(PcDescriptors);
-MESSAGE_SNAPSHOT_UNREACHABLE(RedirectionData);
-MESSAGE_SNAPSHOT_UNREACHABLE(Script);
-MESSAGE_SNAPSHOT_UNREACHABLE(SignatureData);
-MESSAGE_SNAPSHOT_UNREACHABLE(SingleTargetCache);
-MESSAGE_SNAPSHOT_UNREACHABLE(StackMap);
-MESSAGE_SNAPSHOT_UNREACHABLE(String);
-MESSAGE_SNAPSHOT_UNREACHABLE(SubtypeTestCache);
-MESSAGE_SNAPSHOT_UNREACHABLE(TypedDataBase);
-MESSAGE_SNAPSHOT_UNREACHABLE(UnlinkedCall);
-MESSAGE_SNAPSHOT_UNREACHABLE(UnwindError);
+RawUnlinkedCall* UnlinkedCall::ReadFrom(SnapshotReader* reader,
+                                        intptr_t object_id,
+                                        intptr_t tags,
+                                        Snapshot::Kind kind,
+                                        bool as_reference) {
+  UNREACHABLE();
+  return UnlinkedCall::null();
+}
 
-MESSAGE_SNAPSHOT_ILLEGAL(DynamicLibrary);
-MESSAGE_SNAPSHOT_ILLEGAL(MirrorReference);
-MESSAGE_SNAPSHOT_ILLEGAL(Pointer);
-MESSAGE_SNAPSHOT_ILLEGAL(ReceivePort);
-MESSAGE_SNAPSHOT_ILLEGAL(StackTrace);
-MESSAGE_SNAPSHOT_ILLEGAL(UserTag);
+void RawUnlinkedCall::WriteTo(SnapshotWriter* writer,
+                              intptr_t object_id,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  UNREACHABLE();
+}
+
+RawICData* ICData::ReadFrom(SnapshotReader* reader,
+                            intptr_t object_id,
+                            intptr_t tags,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  UNREACHABLE();
+  return ICData::null();
+}
+
+void RawICData::WriteTo(SnapshotWriter* writer,
+                        intptr_t object_id,
+                        Snapshot::Kind kind,
+                        bool as_reference) {
+  UNREACHABLE();
+}
+
+RawMegamorphicCache* MegamorphicCache::ReadFrom(SnapshotReader* reader,
+                                                intptr_t object_id,
+                                                intptr_t tags,
+                                                Snapshot::Kind kind,
+                                                bool as_reference) {
+  UNREACHABLE();
+  return MegamorphicCache::null();
+}
+
+void RawMegamorphicCache::WriteTo(SnapshotWriter* writer,
+                                  intptr_t object_id,
+                                  Snapshot::Kind kind,
+                                  bool as_reference) {
+  UNREACHABLE();
+}
+
+RawSubtypeTestCache* SubtypeTestCache::ReadFrom(SnapshotReader* reader,
+                                                intptr_t object_id,
+                                                intptr_t tags,
+                                                Snapshot::Kind kind,
+                                                bool as_reference) {
+  UNREACHABLE();
+  return SubtypeTestCache::null();
+}
+
+void RawSubtypeTestCache::WriteTo(SnapshotWriter* writer,
+                                  intptr_t object_id,
+                                  Snapshot::Kind kind,
+                                  bool as_reference) {
+  UNREACHABLE();
+}
+
+RawError* Error::ReadFrom(SnapshotReader* reader,
+                          intptr_t object_id,
+                          intptr_t tags,
+                          Snapshot::Kind kind,
+                          bool as_referenec) {
+  UNREACHABLE();
+  return Error::null();  // Error is an abstract class.
+}
+
+void RawError::WriteTo(SnapshotWriter* writer,
+                       intptr_t object_id,
+                       Snapshot::Kind kind,
+                       bool as_reference) {
+  UNREACHABLE();  // Error is an abstract class.
+}
 
 RawApiError* ApiError::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
@@ -666,6 +1047,22 @@
   visitor.VisitPointers(from(), to());
 }
 
+RawUnwindError* UnwindError::ReadFrom(SnapshotReader* reader,
+                                      intptr_t object_id,
+                                      intptr_t tags,
+                                      Snapshot::Kind kind,
+                                      bool as_reference) {
+  UNREACHABLE();
+  return UnwindError::null();
+}
+
+void RawUnwindError::WriteTo(SnapshotWriter* writer,
+                             intptr_t object_id,
+                             Snapshot::Kind kind,
+                             bool as_reference) {
+  UNREACHABLE();
+}
+
 RawInstance* Instance::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
@@ -799,6 +1196,22 @@
   writer->WriteDouble(ptr()->value_);
 }
 
+RawString* String::ReadFrom(SnapshotReader* reader,
+                            intptr_t object_id,
+                            intptr_t tags,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  UNREACHABLE();  // String is an abstract class.
+  return String::null();
+}
+
+void RawString::WriteTo(SnapshotWriter* writer,
+                        intptr_t object_id,
+                        Snapshot::Kind kind,
+                        bool as_reference) {
+  UNREACHABLE();  // String is an abstract class.
+}
+
 template <typename StringType, typename CharacterType, typename CallbackType>
 void String::ReadFromImpl(SnapshotReader* reader,
                           String* str_obj,
@@ -952,6 +1365,22 @@
                 ptr()->external_data_);
 }
 
+RawBool* Bool::ReadFrom(SnapshotReader* reader,
+                        intptr_t object_id,
+                        intptr_t tags,
+                        Snapshot::Kind kind,
+                        bool as_reference) {
+  UNREACHABLE();
+  return Bool::null();
+}
+
+void RawBool::WriteTo(SnapshotWriter* writer,
+                      intptr_t object_id,
+                      Snapshot::Kind kind,
+                      bool as_reference) {
+  UNREACHABLE();
+}
+
 RawArray* Array::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
@@ -1293,6 +1722,22 @@
   writer->Write<double>(ptr()->value_[1]);
 }
 
+RawTypedDataBase* TypedDataBase::ReadFrom(SnapshotReader* reader,
+                                          intptr_t object_id,
+                                          intptr_t tags,
+                                          Snapshot::Kind kind,
+                                          bool as_reference) {
+  UNREACHABLE();  // TypedDataBase is an abstract class.
+  return NULL;
+}
+
+void RawTypedDataBase::WriteTo(SnapshotWriter* writer,
+                               intptr_t object_id,
+                               Snapshot::Kind kind,
+                               bool as_reference) {
+  UNREACHABLE();  // TypedDataBase is an abstract class.
+}
+
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
@@ -1576,6 +2021,38 @@
   return view.raw();
 }
 
+RawPointer* Pointer::ReadFrom(SnapshotReader* reader,
+                              intptr_t object_id,
+                              intptr_t tags,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  FATAL("Snapshotting Pointers is not supported");
+  UNREACHABLE();
+}
+
+void RawPointer::WriteTo(SnapshotWriter* writer,
+                         intptr_t object_id,
+                         Snapshot::Kind kind,
+                         bool as_reference) {
+  FATAL("Snapshotting Pointers is not supported");
+}
+
+RawDynamicLibrary* DynamicLibrary::ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind,
+                                            bool as_reference) {
+  FATAL("Snapshotting DynamicLibraries is not supported");
+  UNREACHABLE();
+}
+
+void RawDynamicLibrary::WriteTo(SnapshotWriter* writer,
+                                intptr_t object_id,
+                                Snapshot::Kind kind,
+                                bool as_reference) {
+  FATAL("Snapshotting DynamicLibraries is not supported");
+}
+
 RawCapability* Capability::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
@@ -1603,6 +2080,29 @@
   writer->Write<uint64_t>(ptr()->id_);
 }
 
+RawReceivePort* ReceivePort::ReadFrom(SnapshotReader* reader,
+                                      intptr_t object_id,
+                                      intptr_t tags,
+                                      Snapshot::Kind kind,
+                                      bool as_reference) {
+  UNREACHABLE();
+  return ReceivePort::null();
+}
+
+void RawReceivePort::WriteTo(SnapshotWriter* writer,
+                             intptr_t object_id,
+                             Snapshot::Kind kind,
+                             bool as_reference) {
+  if (kind == Snapshot::kMessage) {
+    // We do not allow objects with native fields in an isolate message.
+    writer->SetWriteException(Exceptions::kArgument,
+                              "Illegal argument in isolate message"
+                              " : (object is a RawReceivePort)");
+  } else {
+    UNREACHABLE();
+  }
+}
+
 RawSendPort* SendPort::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
@@ -1696,6 +2196,25 @@
       });
 }
 
+RawStackTrace* StackTrace::ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind,
+                                    bool as_reference) {
+  UNREACHABLE();  // StackTraces are not sent in a snapshot.
+  return StackTrace::null();
+}
+
+void RawStackTrace::WriteTo(SnapshotWriter* writer,
+                            intptr_t object_id,
+                            Snapshot::Kind kind,
+                            bool as_reference) {
+  ASSERT(kind == Snapshot::kMessage);
+  writer->SetWriteException(Exceptions::kArgument,
+                            "Illegal argument in isolate message"
+                            " : (object is a stacktrace)");
+}
+
 RawRegExp* RegExp::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
@@ -1790,4 +2309,50 @@
   visitor.VisitPointers(from(), to());
 }
 
+RawMirrorReference* MirrorReference::ReadFrom(SnapshotReader* reader,
+                                              intptr_t object_id,
+                                              intptr_t tags,
+                                              Snapshot::Kind kind,
+                                              bool as_referenec) {
+  UNREACHABLE();
+  return MirrorReference::null();
+}
+
+void RawMirrorReference::WriteTo(SnapshotWriter* writer,
+                                 intptr_t object_id,
+                                 Snapshot::Kind kind,
+                                 bool as_reference) {
+  if (kind == Snapshot::kMessage) {
+    // We do not allow objects with native fields in an isolate message.
+    writer->SetWriteException(Exceptions::kArgument,
+                              "Illegal argument in isolate message"
+                              " : (object is a MirrorReference)");
+  } else {
+    UNREACHABLE();
+  }
+}
+
+RawUserTag* UserTag::ReadFrom(SnapshotReader* reader,
+                              intptr_t object_id,
+                              intptr_t tags,
+                              Snapshot::Kind kind,
+                              bool as_reference) {
+  UNREACHABLE();
+  return UserTag::null();
+}
+
+void RawUserTag::WriteTo(SnapshotWriter* writer,
+                         intptr_t object_id,
+                         Snapshot::Kind kind,
+                         bool as_reference) {
+  if (kind == Snapshot::kMessage) {
+    // We do not allow objects with native fields in an isolate message.
+    writer->SetWriteException(Exceptions::kArgument,
+                              "Illegal argument in isolate message"
+                              " : (object is a UserTag)");
+  } else {
+    UNREACHABLE();
+  }
+}
+
 }  // namespace dart
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index e997516..674623b 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -356,7 +356,7 @@
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& function_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
-  ASSERT(!type.IsNull());
+  ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator_type_arguments.IsNull() ||
          instantiator_type_arguments.IsInstantiated());
   ASSERT(function_type_arguments.IsNull() ||
diff --git a/runtime/vm/snapshot.h b/runtime/vm/snapshot.h
index 5f6c929..0939635e 100644
--- a/runtime/vm/snapshot.h
+++ b/runtime/vm/snapshot.h
@@ -5,9 +5,6 @@
 #ifndef RUNTIME_VM_SNAPSHOT_H_
 #define RUNTIME_VM_SNAPSHOT_H_
 
-#include <memory>
-#include <utility>
-
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ -703,7 +700,6 @@
   friend class RawClosureData;
   friend class RawCode;
   friend class RawContextScope;
-  friend class RawDynamicLibrary;
   friend class RawExceptionHandlers;
   friend class RawField;
   friend class RawFunction;
@@ -715,7 +711,6 @@
   friend class RawLocalVarDescriptors;
   friend class RawMirrorReference;
   friend class RawObjectPool;
-  friend class RawPointer;
   friend class RawReceivePort;
   friend class RawRegExp;
   friend class RawScript;
@@ -723,10 +718,10 @@
   friend class RawSubtypeTestCache;
   friend class RawTransferableTypedData;
   friend class RawType;
+  friend class RawTypedDataView;
+  friend class RawTypeRef;
   friend class RawTypeArguments;
   friend class RawTypeParameter;
-  friend class RawTypeRef;
-  friend class RawTypedDataView;
   friend class RawUserTag;
   friend class SnapshotWriterVisitor;
   friend class WriteInlinedObjectVisitor;
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index b17870e..5454049 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -18,6 +18,8 @@
 // One-character symbols are added implicitly.
 #define PREDEFINED_SYMBOLS_LIST(V)                                             \
   V(AbstractClassInstantiationError, "AbstractClassInstantiationError")        \
+  V(AddError, "addError")                                                      \
+  V(AddStream, "addStream")                                                    \
   V(AllocateInvocationMirror, "_allocateInvocationMirror")                     \
   V(AllocateInvocationMirrorForClosure, "_allocateInvocationMirrorForClosure") \
   V(AnonymousClosure, "<anonymous closure>")                                   \
@@ -27,12 +29,26 @@
   V(ArgumentError, "ArgumentError")                                            \
   V(AssertionError, "_AssertionError")                                         \
   V(AssignIndexToken, "[]=")                                                   \
+  V(Async, "async")                                                            \
+  V(AsyncAwaitHelper, "_awaitHelper")                                          \
+  V(AsyncCatchErrorCallback, ":async_op_catch_error")                          \
+  V(AsyncCatchHelper, "_asyncCatchHelper")                                     \
   V(AsyncCompleter, ":async_completer")                                        \
+  V(AsyncErrorWrapperHelper, "_asyncErrorWrapperHelper")                       \
   V(AsyncOperation, ":async_op")                                               \
+  V(AsyncOperationErrorParam, ":async_error_param")                            \
+  V(AsyncOperationParam, ":async_result")                                      \
+  V(AsyncOperationStackTraceParam, ":async_stack_trace_param")                 \
+  V(AsyncSavedTryCtxVarPrefix, ":async_saved_try_ctx_var_")                    \
+  V(AsyncStackTraceHelper, "_asyncStackTraceHelper")                           \
   V(AsyncStackTraceVar, ":async_stack_trace")                                  \
   V(AsyncStarMoveNextHelper, "_asyncStarMoveNextHelper")                       \
+  V(AsyncThenCallback, ":async_op_then")                                       \
+  V(AsyncThenWrapperHelper, "_asyncThenWrapperHelper")                         \
+  V(Await, "await")                                                            \
   V(AwaitContextVar, ":await_ctx_var")                                         \
   V(AwaitJumpVar, ":await_jump_var")                                           \
+  V(AwaitTempVarPrefix, ":await_temp_var_")                                    \
   V(Bool, "bool")                                                              \
   V(BooleanExpression, "boolean expression")                                   \
   V(BoundsCheckForPartialInstantiation, "_boundsCheckForPartialInstantiation") \
@@ -46,13 +62,18 @@
   V(Class, "Class")                                                            \
   V(ClassID, "ClassID")                                                        \
   V(ClearAsyncThreadStackTrace, "_clearAsyncThreadStackTrace")                 \
+  V(Close, "close")                                                            \
   V(ClosureData, "ClosureData")                                                \
   V(ClosureParameter, ":closure")                                              \
   V(Code, "Code")                                                              \
   V(CodeSourceMap, "CodeSourceMap")                                            \
+  V(ColonController, ":controller")                                            \
   V(ColonMatcher, ":matcher")                                                  \
+  V(ColonStream, ":stream")                                                    \
   V(CommaSpace, ", ")                                                          \
   V(Completer, "Completer")                                                    \
+  V(CompleterComplete, "complete")                                             \
+  V(CompleterCompleteError, "completeError")                                   \
   V(CompleterFuture, "future")                                                 \
   V(CompleterGetFuture, "get:future")                                          \
   V(CompleterSyncConstructor, "Completer.sync")                                \
@@ -73,6 +94,7 @@
   V(DartFfiLibName, "ffi")                                                     \
   V(DartIOLibName, "dart.io")                                                  \
   V(DartInternal, "dart:_internal")                                            \
+  V(DartInternalPackage, "package:dart_internal/")                             \
   V(DartIsVM, "dart.isVM")                                                     \
   V(DartIsolate, "dart:isolate")                                               \
   V(DartLibrary, "dart.library.")                                              \
@@ -90,6 +112,7 @@
   V(DebugProcedureName, ":Eval")                                               \
   V(Default, "Default")                                                        \
   V(DefaultLabel, ":L")                                                        \
+  V(DeoptInfo, "DeoptInfo")                                                    \
   V(DotCreate, "._create")                                                     \
   V(DotRange, ".range")                                                        \
   V(DotValue, ".value")                                                        \
@@ -136,6 +159,7 @@
   V(Float64List, "Float64List")                                                \
   V(Float64x2, "Float64x2")                                                    \
   V(Float64x2List, "Float64x2List")                                            \
+  V(ForInIter, ":for-in-iter")                                                 \
   V(FormatException, "FormatException")                                        \
   V(ForwardingCorpse, "ForwardingCorpse")                                      \
   V(FreeListElement, "FreeListElement")                                        \
@@ -157,10 +181,12 @@
   V(GrowRegExpStack, "_growRegExpStack")                                       \
   V(HandleExposedException, "_handleExposedException")                         \
   V(HaveSameRuntimeType, "_haveSameRuntimeType")                               \
+  V(Hide, "hide")                                                              \
   V(ICData, "ICData")                                                          \
   V(Identical, "identical")                                                    \
   V(ImmutableMap, "_ImmutableMap")                                             \
   V(ImmutableMapConstructor, "_ImmutableMap._create")                          \
+  V(ImplicitClosure, "<implicit closure>")                                     \
   V(InTypeCast, " in type cast")                                               \
   V(Index, "index")                                                            \
   V(IndexToken, "[]")                                                          \
@@ -190,6 +216,7 @@
   V(LibraryPrefix, "LibraryPrefix")                                            \
   V(List, "List")                                                              \
   V(ListFactory, "List.")                                                      \
+  V(ListLiteralElement, "list literal element")                                \
   V(ListLiteralFactory, "List._fromLiteral")                                   \
   V(LoadLibrary, "loadLibrary")                                                \
   V(LocalVarDescriptors, "LocalVarDescriptors")                                \
@@ -209,13 +236,14 @@
   V(Number, "num")                                                             \
   V(Object, "Object")                                                          \
   V(ObjectPool, "ObjectPool")                                                  \
+  V(Of, "of")                                                                  \
+  V(On, "on")                                                                  \
   V(OneByteString, "_OneByteString")                                           \
   V(OptimizedOut, "<optimized out>")                                           \
   V(OriginalParam, ":original:")                                               \
   V(Other, "other")                                                            \
   V(OutOfMemoryError, "OutOfMemoryError")                                      \
   V(PackageScheme, "package:")                                                 \
-  V(ParameterTypeCheck, "ParameterTypeCheck")                                  \
   V(Patch, "patch")                                                            \
   V(PatchClass, "PatchClass")                                                  \
   V(PcDescriptors, "PcDescriptors")                                            \
@@ -227,11 +255,14 @@
   V(RedirectionData, "RedirectionData")                                        \
   V(RegExp, "RegExp")                                                          \
   V(RightShiftOperator, ">>")                                                  \
+  V(SavedExceptionVar, ":saved_exception_var")                                 \
+  V(SavedStackTraceVar, ":saved_stack_trace_var")                              \
   V(SavedTryContextVar, ":saved_try_context_var")                              \
   V(Script, "Script")                                                          \
   V(Set, "set")                                                                \
   V(SetAsyncThreadStackTrace, "_setAsyncThreadStackTrace")                     \
   V(SetterPrefix, "set:")                                                      \
+  V(Show, "show")                                                              \
   V(SignatureData, "SignatureData")                                            \
   V(SingleTargetCache, "SingleTargetCache")                                    \
   V(SpaceExtendsSpace, " extends ")                                            \
@@ -250,6 +281,8 @@
   V(SwitchExpr, ":switch_expr")                                                \
   V(Symbol, "Symbol")                                                          \
   V(SymbolCtor, "Symbol.")                                                     \
+  V(Sync, "sync")                                                              \
+  V(TempParam, ":temp_param")                                                  \
   V(ThrowNew, "_throwNew")                                                     \
   V(ThrowNewInvocation, "_throwNewInvocation")                                 \
   V(TopLevel, "::")                                                            \
@@ -257,6 +290,7 @@
   V(TransferableTypedData, "TransferableTypedData")                            \
   V(TryFinallyReturnValue, ":try_finally_return_value")                        \
   V(TwoByteString, "_TwoByteString")                                           \
+  V(TwoNewlines, "\n\n")                                                       \
   V(TwoSpaces, "  ")                                                           \
   V(Type, "Type")                                                              \
   V(TypeArguments, "TypeArguments")                                            \
@@ -296,6 +330,8 @@
   V(_DeletedEnumPrefix, "Deleted enum value from ")                            \
   V(_DeletedEnumSentinel, "_deleted_enum_sentinel")                            \
   V(_Double, "_Double")                                                        \
+  V(_EnumHelper, "_EnumHelper")                                                \
+  V(_EnumNames, "_enum_names")                                                 \
   V(_ExternalFloat32Array, "_ExternalFloat32Array")                            \
   V(_ExternalFloat32x4Array, "_ExternalFloat32x4Array")                        \
   V(_ExternalFloat64Array, "_ExternalFloat64Array")                            \
@@ -417,6 +453,7 @@
   V(_stackTrace, "_stackTrace")                                                \
   V(_state, "_state")                                                          \
   V(_wordCharacterMap, "_wordCharacterMap")                                    \
+  V(_yieldEachIterable, "_yieldEachIterable")                                  \
   V(add, "add")                                                                \
   V(capture_length, ":capture_length")                                         \
   V(capture_start_index, ":capture_start_index")                               \
@@ -449,7 +486,8 @@
   V(vm_entry_point, "vm:entry-point")                                          \
   V(vm_exact_result_type, "vm:exact-result-type")                              \
   V(vm_non_nullable_result_type, "vm:non-nullable-result-type")                \
-  V(vm_trace_entrypoints, "vm:testing.unsafe.trace-entrypoints-fn")
+  V(vm_trace_entrypoints, "vm:testing.unsafe.trace-entrypoints-fn")            \
+  V(word_character_map, ":word_character_map")
 
 // Contains a list of frequently used strings in a canonicalized form. This
 // list is kept in the vm_isolate in order to share the copy across isolates