diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 7c7e830..752bd26 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.3.29";
+  public static final String LABEL = "1.3.30";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index e655c0e..d8d3823 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.CallSiteInformation;
 import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.Inliner.InlineeWithReason;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.utils.InternalOptions;
@@ -227,6 +228,14 @@
       Code code = candidate.getCode();
       int instructionLimit = computeInstructionLimit(invoke, candidate);
       if (!code.estimatedSizeForInliningAtMost(instructionLimit)) {
+        if (info != null) {
+          info.exclude(
+              invoke,
+              "instruction limit exceeds: "
+                  + code.estimatedSizeForInlining()
+                  + " <= "
+                  + instructionLimit);
+        }
         return false;
       }
     }
@@ -357,13 +366,59 @@
   }
 
   @Override
-  public boolean exceededAllowance() {
+  public boolean stillHasBudget() {
+    return instructionAllowance > 0;
+  }
+
+  @Override
+  public boolean willExceedBudget(InlineeWithReason inlinee, BasicBlock block) {
+    if (inlinee.reason.mustBeInlined()) {
+      return false;
+    }
+
+    if (block.hasCatchHandlers() && inlinee.reason != Reason.FORCE) {
+      // Inlining could lead to an explosion of move-exception and resolution moves. As an
+      // example, consider the following piece of code.
+      //   try {
+      //     ...
+      //     foo();
+      //     ...
+      //   } catch (A e) { ... }
+      //   } catch (B e) { ... }
+      //   } catch (C e) { ... }
+      //
+      // The generated code for the above example will have a move-exception instruction
+      // for each of the three catch handlers. Furthermore, the blocks with these move-
+      // exception instructions may require a number of resolution moves to setup the
+      // register state for the catch handlers. When inlining foo(), the generated code
+      // will have a move-exception instruction *for each of the instructions in foo()
+      // that can throw*, along with the necessary resolution moves for each exception-
+      // edge. We therefore abort inlining if the number of exception-edges explode.
+      int numberOfThrowingInstructionsInInlinee = 0;
+      for (BasicBlock inlineeBlock : inlinee.code.blocks) {
+        numberOfThrowingInstructionsInInlinee += inlineeBlock.numberOfThrowingInstructions();
+      }
+      // Estimate the number of "control flow resolution blocks", where we will insert a
+      // move-exception instruction (if needed), along with all the resolution moves that
+      // will be needed to setup the register state for the catch handler.
+      int estimatedNumberOfControlFlowResolutionBlocks =
+          numberOfThrowingInstructionsInInlinee * block.numberOfCatchHandlers();
+      // Abort if inlining could lead to an explosion in the number of control flow
+      // resolution blocks that setup the register state before the actual catch handler.
+      if (estimatedNumberOfControlFlowResolutionBlocks
+          >= options.inliningControlFlowResolutionBlocksThreshold) {
+        return true;
+      }
+    }
+
+    // Allow the first method to consume more than the allowance to be inlined.
     return instructionAllowance < 0;
   }
 
   @Override
-  public void markInlined(IRCode inlinee) {
-    instructionAllowance -= inliner.numberOfInstructions(inlinee);
+  public void markInlined(InlineeWithReason inlinee) {
+    // TODO(118734615): All inlining use from the budget - should that only be SIMPLE?
+    instructionAllowance -= inliner.numberOfInstructions(inlinee.code);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
index ca82166..6890dd8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.code.InvokePolymorphic;
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.Inliner.InlineeWithReason;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import java.util.ListIterator;
 import java.util.Map;
@@ -78,15 +79,19 @@
       IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block) {}
 
   @Override
-  public boolean exceededAllowance() {
-    return false; // Never exceeds allowance.
+  public boolean stillHasBudget() {
+    return true; // Unlimited allowance.
   }
 
   @Override
-  public void markInlined(IRCode inlinee) {
+  public boolean willExceedBudget(InlineeWithReason inlinee, BasicBlock block) {
+    return false; // Unlimited allowance.
   }
 
   @Override
+  public void markInlined(InlineeWithReason inlinee) {}
+
+  @Override
   public DexType getReceiverTypeIfKnown(InvokeMethod invoke) {
     assert invoke.isInvokeMethodWithReceiver();
     Inliner.InliningInfo info = invokesToInline.get(invoke.asInvokeMethodWithReceiver());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index fcb7293..17ba5d7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -42,10 +42,6 @@
 import java.util.stream.Collectors;
 
 public class Inliner {
-  private static final int INITIAL_INLINING_INSTRUCTION_ALLOWANCE = 1500;
-
-  // Threshold found empirically by testing on GMS Core.
-  private static final int CONTROL_FLOW_RESOLUTION_BLOCKS_THRESHOLD = 15;
 
   private final IRConverter converter;
   protected final AppInfoWithLiveness appInfo;
@@ -391,7 +387,12 @@
     ALWAYS,        // Inlinee is marked for inlining due to alwaysinline directive.
     SINGLE_CALLER, // Inlinee has precisely one caller.
     DUAL_CALLER,   // Inlinee has precisely two callers.
-    SIMPLE,        // Inlinee has simple code suitable for inlining.
+    SIMPLE;        // Inlinee has simple code suitable for inlining.
+
+    public boolean mustBeInlined() {
+      // TODO(118734615): Include SINGLE_CALLER and DUAL_CALLER here as well?
+      return this == FORCE || this == ALWAYS;
+    }
   }
 
   static public class InlineAction {
@@ -406,11 +407,7 @@
       this.reason = reason;
     }
 
-    boolean ignoreInstructionBudget() {
-      return reason != Reason.SIMPLE;
-    }
-
-    public IRCode buildInliningIR(
+    public InlineeWithReason buildInliningIR(
         ValueNumberGenerator generator,
         AppInfoWithSubtyping appInfo,
         GraphLense graphLense,
@@ -423,7 +420,18 @@
       if (!target.isProcessed()) {
         new LensCodeRewriter(graphLense, appInfo).rewrite(code, target);
       }
-      return code;
+      return new InlineeWithReason(code, reason);
+    }
+  }
+
+  public static class InlineeWithReason {
+
+    final Reason reason;
+    final IRCode code;
+
+    InlineeWithReason(IRCode code, Reason reason) {
+      this.code = code;
+      this.reason = reason;
     }
   }
 
@@ -538,11 +546,14 @@
       Predicate<DexEncodedMethod> isProcessedConcurrently,
       CallSiteInformation callSiteInformation) {
 
-    DefaultInliningOracle oracle = createDefaultOracle(
-        method, code,
-        isProcessedConcurrently, callSiteInformation,
-        options.inliningInstructionLimit,
-        INITIAL_INLINING_INSTRUCTION_ALLOWANCE - numberOfInstructions(code));
+    DefaultInliningOracle oracle =
+        createDefaultOracle(
+            method,
+            code,
+            isProcessedConcurrently,
+            callSiteInformation,
+            options.inliningInstructionLimit,
+            options.inliningInstructionAllowance - numberOfInstructions(code));
 
     performInliningImpl(oracle, oracle, method, code);
   }
@@ -568,24 +579,23 @@
 
   private void performInliningImpl(
       InliningStrategy strategy, InliningOracle oracle, DexEncodedMethod method, IRCode code) {
-    if (strategy.exceededAllowance()) {
-      return;
-    }
-
     List<BasicBlock> blocksToRemove = new ArrayList<>();
     ListIterator<BasicBlock> blockIterator = code.listIterator();
-    while (blockIterator.hasNext() && !strategy.exceededAllowance()) {
+    while (blockIterator.hasNext()) {
       BasicBlock block = blockIterator.next();
       if (blocksToRemove.contains(block)) {
         continue;
       }
       InstructionListIterator iterator = block.listIterator();
-      while (iterator.hasNext() && !strategy.exceededAllowance()) {
+      while (iterator.hasNext()) {
         Instruction current = iterator.next();
         if (current.isInvokeMethod()) {
           InvokeMethod invoke = current.asInvokeMethod();
           InlineAction result = invoke.computeInlining(oracle, method.method.holder);
           if (result != null) {
+            if (!(strategy.stillHasBudget() || result.reason.mustBeInlined())) {
+              continue;
+            }
             DexEncodedMethod target = result.target;
             Position invokePosition = invoke.getPosition();
             if (invokePosition.method == null) {
@@ -596,53 +606,26 @@
                 || invokePosition.getOutermostCaller().method
                     == converter.getGraphLense().getOriginalMethodSignature(method.method);
 
-            IRCode inlinee =
-                result.buildInliningIR(code.valueNumberGenerator,
-                    appInfo, converter.getGraphLense(), options, invokePosition);
+            InlineeWithReason inlinee =
+                result.buildInliningIR(
+                    code.valueNumberGenerator,
+                    appInfo,
+                    converter.getGraphLense(),
+                    options,
+                    invokePosition);
+
             if (inlinee != null) {
-              if (block.hasCatchHandlers() && !(oracle instanceof ForcedInliningOracle)) {
-                // Inlining could lead to an explosion of move-exception and resolution moves. As an
-                // example, consider the following piece of code.
-                //   try {
-                //     ...
-                //     foo();
-                //     ...
-                //   } catch (A e) { ... }
-                //   } catch (B e) { ... }
-                //   } catch (C e) { ... }
-                //
-                // The generated code for the above example will have a move-exception instruction
-                // for each of the three catch handlers. Furthermore, the blocks with these move-
-                // exception instructions may require a number of resolution moves to setup the
-                // register state for the catch handlers. When inlining foo(), the generated code
-                // will have a move-exception instruction *for each of the instructions in foo()
-                // that can throw*, along with the necessary resolution moves for each exception-
-                // edge. We therefore abort inlining if the number of exception-edges explode.
-                int numberOfThrowingInstructionsInInlinee = 0;
-                for (BasicBlock inlineeBlock : inlinee.blocks) {
-                  numberOfThrowingInstructionsInInlinee +=
-                      inlineeBlock.numberOfThrowingInstructions();
-                }
-                // Estimate the number of "control flow resolution blocks", where we will insert a
-                // move-exception instruction (if needed), along with all the resolution moves that
-                // will be needed to setup the register state for the catch handler.
-                int estimatedNumberOfControlFlowResolutionBlocks =
-                    numberOfThrowingInstructionsInInlinee * block.numberOfCatchHandlers();
-                // Abort if inlining could lead to an explosion in the number of control flow
-                // resolution blocks that setup the register state before the actual catch handler.
-                if (estimatedNumberOfControlFlowResolutionBlocks
-                    >= CONTROL_FLOW_RESOLUTION_BLOCKS_THRESHOLD) {
-                  continue;
-                }
+              if (strategy.willExceedBudget(inlinee, block)) {
+                continue;
               }
 
               // If this code did not go through the full pipeline, apply inlining to make sure
               // that force inline targets get processed.
-              strategy.ensureMethodProcessed(target, inlinee);
+              strategy.ensureMethodProcessed(target, inlinee.code);
 
               // Make sure constructor inlining is legal.
               assert !target.isClassInitializer();
-              if (!strategy.isValidTarget(invoke, target, inlinee)) {
+              if (!strategy.isValidTarget(invoke, target, inlinee.code)) {
                 continue;
               }
               DexType downcast = getDowncastTypeIfNeeded(strategy, invoke, target);
@@ -650,20 +633,18 @@
               // Back up before the invoke instruction.
               iterator.previous();
               strategy.markInlined(inlinee);
-              if (!strategy.exceededAllowance() || result.ignoreInstructionBudget()) {
-                iterator.inlineInvoke(
-                    appInfo, code, inlinee, blockIterator, blocksToRemove, downcast);
-                strategy.updateTypeInformationIfNeeded(inlinee, blockIterator, block);
+              iterator.inlineInvoke(
+                  appInfo, code, inlinee.code, blockIterator, blocksToRemove, downcast);
+              strategy.updateTypeInformationIfNeeded(inlinee.code, blockIterator, block);
 
-                // If we inlined the invoke from a bridge method, it is no longer a bridge method.
-                if (method.accessFlags.isBridge()) {
-                  method.accessFlags.unsetSynthetic();
-                  method.accessFlags.unsetBridge();
-                }
-
-                method.copyMetadataFromInlinee(target);
-                code.copyMetadataFromInlinee(inlinee);
+              // If we inlined the invoke from a bridge method, it is no longer a bridge method.
+              if (method.accessFlags.isBridge()) {
+                method.accessFlags.unsetSynthetic();
+                method.accessFlags.unsetBridge();
               }
+
+              method.copyMetadataFromInlinee(target);
+              code.copyMetadataFromInlinee(inlinee.code);
             }
           }
         }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
index 90554f6..7dc2b62 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
@@ -9,12 +9,23 @@
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.optimize.Inliner.InlineeWithReason;
 import java.util.ListIterator;
 
 interface InliningStrategy {
-  boolean exceededAllowance();
 
-  void markInlined(IRCode inlinee);
+  /** Return true if there is still budget for inlining into this method. */
+  boolean stillHasBudget();
+
+  /**
+   * Check if the inlinee will exceed the the budget for inlining size into current method.
+   *
+   * <p>Return true if the strategy will *not* allow inlining.
+   */
+  boolean willExceedBudget(InlineeWithReason inlinee, BasicBlock block);
+
+  /** Inform the strategy that the inlinee has been inlined. */
+  void markInlined(InlineeWithReason inlinee);
 
   void ensureMethodProcessed(DexEncodedMethod target, IRCode inlinee);
 
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 332b0d3..2612d0b 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -106,7 +106,14 @@
   public boolean enableClassInlining = true;
   public boolean enableClassStaticizer = true;
   public int classInliningInstructionLimit = 50;
+  // This defines the limit of instructions in the inlinee
   public int inliningInstructionLimit = 5;
+  // This defines how many instructions of inlinees we can inlinee overall.
+  public int inliningInstructionAllowance = 1500;
+  // Maximum number of control flow resolution blocks that setup the register state before
+  // the actual catch handler allowed when inlining. Threshold found empirically by testing on
+  // GMS Core.
+  public int inliningControlFlowResolutionBlocksThreshold = 15;
   public boolean enableSwitchMapRemoval = true;
   public final OutlineOptions outline = new OutlineOptions();
   public boolean enableValuePropagation = true;
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index 060d87b..b76e947 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -11,6 +11,7 @@
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
@@ -19,6 +20,7 @@
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
@@ -239,7 +241,12 @@
     // Build with R8
     AndroidApp.Builder builder = AndroidApp.builder();
     builder.addProgramFiles(classpath);
-    AndroidApp app = compileWithR8(builder.build(), proguardRules, optionsConsumer);
+    R8Command.Builder commandBuilder =
+        ToolHelper.prepareR8CommandBuilder(builder.build(), emptyConsumer(Backend.DEX))
+            .addLibraryFiles(runtimeJar(Backend.DEX))
+            .addProguardConfiguration(ImmutableList.of(proguardRules), Origin.unknown());
+    ToolHelper.allowTestProguardOptions(commandBuilder);
+    AndroidApp app = ToolHelper.runR8(commandBuilder.build(), optionsConsumer);
 
     // Materialize file for execution.
     Path generatedDexFile = temp.getRoot().toPath().resolve("classes.jar");
@@ -258,7 +265,9 @@
     }
     assertEquals("JVM and ART output differ", javaResult.stdout, artOutput);
 
-    inspector.inspectApp(app);
+    if (inspector != null) {
+      inspector.inspectApp(app);
+    }
   }
 
   protected void checkClassExistsInInput(String className) {
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithFailedInliningTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithFailedInliningTest.java
new file mode 100644
index 0000000..f17a729
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithFailedInliningTest.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin;
+
+import com.android.tools.r8.utils.InternalOptions;
+import java.util.function.Consumer;
+import org.junit.Test;
+
+public class KotlinLambdaMergingWithFailedInliningTest extends AbstractR8KotlinTestBase {
+  private Consumer<InternalOptions> optionsModifier =
+      o -> {
+        o.enableTreeShaking = true;
+        o.enableMinification = true;
+        o.enableInlining = true;
+        o.enableClassInlining = true;
+        o.enableLambdaMerging = true;
+        o.inliningInstructionAllowance = 3;
+      };
+
+  @Test
+  public void testJStyleRunnable() throws Exception {
+    final String mainClassName = "lambdas_jstyle_runnable.MainKt";
+    runTest("lambdas_jstyle_runnable", mainClassName, optionsModifier, null);
+  }
+}
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer1.kt b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer1.kt
new file mode 100644
index 0000000..fb88996
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer1.kt
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable
+
+private val liveChecker = object : Runnable {
+  override fun run() {
+    if (!Thread.currentThread().isInterrupted) {
+      publish("liveChecker")
+    }
+  }
+}
+
+class Implementer1 {
+  fun getRunnable() : Runnable {
+    return liveChecker
+  }
+}
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer2.kt b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer2.kt
new file mode 100644
index 0000000..034caca
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/Implementer2.kt
@@ -0,0 +1,17 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable
+
+private val statusRunnable = Runnable {
+  if (!Thread.currentThread().isInterrupted) {
+    publish("statusRunnable")
+  }
+}
+
+class Implementer2 {
+  fun getRunnable() : Runnable {
+    return statusRunnable
+  }
+}
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/RunnableRunner.java b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/RunnableRunner.java
new file mode 100644
index 0000000..6ccdf16
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/RunnableRunner.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class RunnableRunner {
+
+  private ThreadPoolExecutor executor;
+  private List<Future> futures;
+
+  RunnableRunner() {
+    executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
+    futures = new ArrayList<Future>();
+  }
+
+  void submit(Runnable runnable) {
+    futures.add(executor.submit(runnable));
+  }
+
+  int size() {
+    return executor.getActiveCount();
+  }
+
+  void waitFutures() {
+    Iterator<Future> it = futures.iterator();
+    try {
+      while (it.hasNext()) {
+        it.next().get(1, TimeUnit.MILLISECONDS);
+      }
+    } catch (Exception e) {
+      // Ignore for testing.
+    } finally {
+      while (it.hasNext()) {
+        try {
+          it.next().get();
+        } catch (Throwable t) {
+          // Ignore too.
+        }
+      }
+      executor.shutdownNow();
+    }
+  }
+}
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer3.kt b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer3.kt
new file mode 100644
index 0000000..b65cff6
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer3.kt
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable.inner
+
+import lambdas_jstyle_runnable.publish
+
+private val innerRunnable = Runnable {
+  if (!Thread.currentThread().isInterrupted) {
+    publish("innerRunnable")
+  }
+}
+
+open class Implementer3(private val priority : Int) : Runnable {
+  override fun run() {
+    Thread.currentThread().priority = priority
+    innerRunnable.run()
+  }
+}
+
+class Delegator3(priority: Int) : Implementer3(priority)
\ No newline at end of file
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer4.kt b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer4.kt
new file mode 100644
index 0000000..6e59424
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/inner/Implementer4.kt
@@ -0,0 +1,21 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable.inner
+
+import lambdas_jstyle_runnable.publish
+
+private val reachableChecker : Runnable by lazy {
+  Runnable {
+    if (!Thread.currentThread().isInterrupted) {
+      publish("reachableChecker")
+    }
+  }
+}
+
+class Implementer4 {
+  fun getRunnable() : Runnable {
+    return reachableChecker
+  }
+}
\ No newline at end of file
diff --git a/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/main.kt b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/main.kt
new file mode 100644
index 0000000..ef5d5cf
--- /dev/null
+++ b/src/test/kotlinR8TestResources/lambdas_jstyle_runnable/main.kt
@@ -0,0 +1,29 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package lambdas_jstyle_runnable
+
+import lambdas_jstyle_runnable.inner.Delegator3
+import lambdas_jstyle_runnable.inner.Implementer4
+import java.util.ArrayDeque
+import java.util.Queue
+
+private val queue : Queue<String> = ArrayDeque<String>()
+
+fun publish(message: String) {
+  queue.add(message)
+}
+
+fun main(args: Array<String>) {
+  assert(queue.isEmpty())
+  val runner = RunnableRunner()
+  runner.submit(Implementer1().getRunnable())
+  runner.submit(Implementer2().getRunnable())
+  runner.submit(Delegator3(Thread.currentThread().priority))
+  if (runner.size() > 2) {
+    runner.submit(Implementer4().getRunnable())
+  }
+  runner.waitFutures()
+  assert(queue.size == 3)
+}