diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index a421fe8..3531dec 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -3242,7 +3242,6 @@
 #define __ compiler->assembler()->
 
 void ThrowErrorSlowPathCode::EmitNativeCode(FlowGraphCompiler* compiler) {
-  RELEASE_ASSERT(try_index_ == compiler->CurrentTryIndex());
   if (compiler::Assembler::EmittingComments()) {
     __ Comment("slow path %s operation", name());
   }
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index c6cda87..25b699c 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -315,11 +315,8 @@
 class ThrowErrorSlowPathCode : public TemplateSlowPathCode<Instruction> {
  public:
   ThrowErrorSlowPathCode(Instruction* instruction,
-                         const RuntimeEntry& runtime_entry,
-                         intptr_t try_index)
-      : TemplateSlowPathCode(instruction),
-        runtime_entry_(runtime_entry),
-        try_index_(try_index) {}
+                         const RuntimeEntry& runtime_entry)
+      : TemplateSlowPathCode(instruction), runtime_entry_(runtime_entry) {}
 
   // This name appears in disassembly.
   virtual const char* name() = 0;
@@ -341,15 +338,14 @@
 
  private:
   const RuntimeEntry& runtime_entry_;
-  const intptr_t try_index_;
 };
 
 class NullErrorSlowPath : public ThrowErrorSlowPathCode {
  public:
-  NullErrorSlowPath(CheckNullInstr* instruction, intptr_t try_index)
+  explicit NullErrorSlowPath(CheckNullInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               GetRuntimeEntry(instruction->exception_type()),
-                               try_index) {}
+                               GetRuntimeEntry(instruction->exception_type())) {
+  }
 
   CheckNullInstr::ExceptionType exception_type() const {
     return instruction()->AsCheckNull()->exception_type();
@@ -376,10 +372,8 @@
 
 class RangeErrorSlowPath : public ThrowErrorSlowPathCode {
  public:
-  RangeErrorSlowPath(GenericCheckBoundInstr* instruction, intptr_t try_index)
-      : ThrowErrorSlowPathCode(instruction,
-                               kRangeErrorRuntimeEntry,
-                               try_index) {}
+  explicit RangeErrorSlowPath(GenericCheckBoundInstr* instruction)
+      : ThrowErrorSlowPathCode(instruction, kRangeErrorRuntimeEntry) {}
   virtual const char* name() { return "check bound"; }
 
   virtual intptr_t GetNumberOfArgumentsForRuntimeCall() {
@@ -394,11 +388,9 @@
 
 class LateInitializationErrorSlowPath : public ThrowErrorSlowPathCode {
  public:
-  LateInitializationErrorSlowPath(LoadFieldInstr* instruction,
-                                  intptr_t try_index)
+  explicit LateInitializationErrorSlowPath(LoadFieldInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kLateFieldNotInitializedErrorRuntimeEntry,
-                               try_index) {}
+                               kLateFieldNotInitializedErrorRuntimeEntry) {}
   virtual const char* name() { return "late initialization error"; }
 
   virtual intptr_t GetNumberOfArgumentsForRuntimeCall() {
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index d4276ad..30240ef 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -4193,7 +4193,7 @@
 
   if (throw_exception_on_initialization()) {
     ThrowErrorSlowPathCode* slow_path =
-        new LateInitializationErrorSlowPath(this, compiler->CurrentTryIndex());
+        new LateInitializationErrorSlowPath(this);
     compiler->AddSlowPathCode(slow_path);
 
     const Register result_reg = locs()->out(0).reg();
@@ -5482,8 +5482,7 @@
   ASSERT(representation() == RequiredInputRepresentation(kIndexPos));
   ASSERT(representation() == RequiredInputRepresentation(kLengthPos));
 
-  RangeErrorSlowPath* slow_path =
-      new RangeErrorSlowPath(this, compiler->CurrentTryIndex());
+  RangeErrorSlowPath* slow_path = new RangeErrorSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
   Location length_loc = locs()->in(kLengthPos);
   Location index_loc = locs()->in(kIndexPos);
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index 30015fa..bc22d90 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -6388,8 +6388,7 @@
     return;
   }
 
-  ThrowErrorSlowPathCode* slow_path =
-      new NullErrorSlowPath(this, compiler->CurrentTryIndex());
+  ThrowErrorSlowPathCode* slow_path = new NullErrorSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   __ BranchIf(EQUAL, slow_path->entry_label());
@@ -6724,10 +6723,9 @@
 
 class ShiftInt64OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction, intptr_t try_index)
+  explicit ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "int64 shift"; }
 
@@ -6818,8 +6816,7 @@
     // Jump to a slow path if shift is larger than 63 or less than 0.
     ShiftInt64OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange()) {
-      slow_path =
-          new (Z) ShiftInt64OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftInt64OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
       __ CompareImmediate(right_hi, 0);
       __ b(slow_path->entry_label(), NE);
@@ -6885,10 +6882,9 @@
 
 class ShiftUint32OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction, intptr_t try_index)
+  explicit ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "uint32 shift"; }
 
@@ -6954,8 +6950,7 @@
     // Jump to a slow path if shift count is > 31 or negative.
     ShiftUint32OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange(kUint32ShiftCountLimit)) {
-      slow_path =
-          new (Z) ShiftUint32OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftUint32OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ CompareImmediate(right_hi, 0);
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index 226200b..e13d55f 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -5406,8 +5406,7 @@
 }
 
 void CheckNullInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ThrowErrorSlowPathCode* slow_path =
-      new NullErrorSlowPath(this, compiler->CurrentTryIndex());
+  ThrowErrorSlowPathCode* slow_path = new NullErrorSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register value_reg = locs()->in(0).reg();
@@ -5490,11 +5489,9 @@
                       Register divisor,
                       Range* divisor_range,
                       Register tmp,
-                      Register out,
-                      intptr_t try_index)
+                      Register out)
       : ThrowErrorSlowPathCode(instruction,
-                               kIntegerDivisionByZeroExceptionRuntimeEntry,
-                               try_index),
+                               kIntegerDivisionByZeroExceptionRuntimeEntry),
         is_mod_(instruction->op_kind() == Token::kMOD),
         divisor_(divisor),
         divisor_range_(divisor_range),
@@ -5618,8 +5615,8 @@
 
   // Prepare a slow path.
   Range* right_range = instruction->right()->definition()->range();
-  Int64DivideSlowPath* slow_path = new (Z) Int64DivideSlowPath(
-      instruction, right, right_range, tmp, out, compiler->CurrentTryIndex());
+  Int64DivideSlowPath* slow_path =
+      new (Z) Int64DivideSlowPath(instruction, right, right_range, tmp, out);
 
   // Handle modulo/division by zero exception on slow path.
   if (slow_path->has_divide_by_zero()) {
@@ -5848,10 +5845,9 @@
 
 class ShiftInt64OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction, intptr_t try_index)
+  explicit ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "int64 shift"; }
 
@@ -5918,8 +5914,7 @@
     // Jump to a slow path if shift is larger than 63 or less than 0.
     ShiftInt64OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange()) {
-      slow_path =
-          new (Z) ShiftInt64OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftInt64OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
       __ CompareImmediate(shift, kShiftCountLimit);
       __ b(slow_path->entry_label(), HI);
@@ -5978,10 +5973,9 @@
 
 class ShiftUint32OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction, intptr_t try_index)
+  explicit ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "uint32 shift"; }
 
@@ -6027,8 +6021,7 @@
 
     // Jump to a slow path if shift count is negative.
     if (!shift_count_in_range) {
-      ShiftUint32OpSlowPath* slow_path =
-          new (Z) ShiftUint32OpSlowPath(this, compiler->CurrentTryIndex());
+      ShiftUint32OpSlowPath* slow_path = new (Z) ShiftUint32OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ tbnz(slow_path->entry_label(), right, kBitsPerWord - 1);
diff --git a/runtime/vm/compiler/backend/il_ia32.cc b/runtime/vm/compiler/backend/il_ia32.cc
index 198e2d4..4d84b62 100644
--- a/runtime/vm/compiler/backend/il_ia32.cc
+++ b/runtime/vm/compiler/backend/il_ia32.cc
@@ -5534,8 +5534,7 @@
 }
 
 void CheckNullInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ThrowErrorSlowPathCode* slow_path =
-      new NullErrorSlowPath(this, compiler->CurrentTryIndex());
+  ThrowErrorSlowPathCode* slow_path = new NullErrorSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register value_reg = locs()->in(0).reg();
@@ -5906,10 +5905,9 @@
 
 class ShiftInt64OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction, intptr_t try_index)
+  explicit ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "int64 shift"; }
 
@@ -6005,8 +6003,7 @@
     // Jump to a slow path if shift count is > 63 or negative.
     ShiftInt64OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange()) {
-      slow_path =
-          new (Z) ShiftInt64OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftInt64OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
       __ testl(right_hi, right_hi);
       __ j(NOT_ZERO, slow_path->entry_label());
@@ -6069,10 +6066,9 @@
 
 class ShiftUint32OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction, intptr_t try_index)
+  explicit ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "uint32 shift"; }
 
@@ -6140,8 +6136,7 @@
     // Jump to a slow path if shift count is > 31 or negative.
     ShiftUint32OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange(kUint32ShiftCountLimit)) {
-      slow_path =
-          new (Z) ShiftUint32OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftUint32OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ testl(right_hi, right_hi);
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 2ad4305..97f1552 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -5823,8 +5823,7 @@
 }
 
 void CheckNullInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ThrowErrorSlowPathCode* slow_path =
-      new NullErrorSlowPath(this, compiler->CurrentTryIndex());
+  ThrowErrorSlowPathCode* slow_path = new NullErrorSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register value_reg = locs()->in(0).reg();
@@ -5944,11 +5943,9 @@
  public:
   Int64DivideSlowPath(BinaryInt64OpInstr* instruction,
                       Register divisor,
-                      Range* divisor_range,
-                      intptr_t try_index)
+                      Range* divisor_range)
       : ThrowErrorSlowPathCode(instruction,
-                               kIntegerDivisionByZeroExceptionRuntimeEntry,
-                               try_index),
+                               kIntegerDivisionByZeroExceptionRuntimeEntry),
         is_mod_(instruction->op_kind() == Token::kMOD),
         divisor_(divisor),
         divisor_range_(divisor_range),
@@ -6105,8 +6102,8 @@
 
   // Prepare a slow path.
   Range* right_range = instruction->right()->definition()->range();
-  Int64DivideSlowPath* slow_path = new (Z) Int64DivideSlowPath(
-      instruction, right, right_range, compiler->CurrentTryIndex());
+  Int64DivideSlowPath* slow_path =
+      new (Z) Int64DivideSlowPath(instruction, right, right_range);
 
   // Handle modulo/division by zero exception on slow path.
   if (slow_path->has_divide_by_zero()) {
@@ -6372,10 +6369,9 @@
 
 class ShiftInt64OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction, intptr_t try_index)
+  explicit ShiftInt64OpSlowPath(ShiftInt64OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "int64 shift"; }
 
@@ -6442,8 +6438,7 @@
     // Jump to a slow path if shift count is > 63 or negative.
     ShiftInt64OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange()) {
-      slow_path =
-          new (Z) ShiftInt64OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftInt64OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ cmpq(RCX, compiler::Immediate(kShiftCountLimit));
@@ -6500,10 +6495,9 @@
 
 class ShiftUint32OpSlowPath : public ThrowErrorSlowPathCode {
  public:
-  ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction, intptr_t try_index)
+  explicit ShiftUint32OpSlowPath(ShiftUint32OpInstr* instruction)
       : ThrowErrorSlowPathCode(instruction,
-                               kArgumentErrorUnboxedInt64RuntimeEntry,
-                               try_index) {}
+                               kArgumentErrorUnboxedInt64RuntimeEntry) {}
 
   const char* name() override { return "uint32 shift"; }
 
@@ -6559,8 +6553,7 @@
     // Jump to a slow path if shift count is > 31 or negative.
     ShiftUint32OpSlowPath* slow_path = NULL;
     if (!IsShiftCountInRange(kUint32ShiftCountLimit)) {
-      slow_path =
-          new (Z) ShiftUint32OpSlowPath(this, compiler->CurrentTryIndex());
+      slow_path = new (Z) ShiftUint32OpSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ cmpq(RCX, compiler::Immediate(kUint32ShiftCountLimit));
diff --git a/tools/VERSION b/tools/VERSION
index a1a4578..f10e4ba 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 282
+PRERELEASE 283
 PRERELEASE_PATCH 0
\ No newline at end of file