diff --git a/.gitignore b/.gitignore
index f15c3c1..51e0c02 100644
--- a/.gitignore
+++ b/.gitignore
@@ -45,6 +45,8 @@
 third_party/gradle/gradle
 third_party/gradle-plugin
 third_party/gradle-plugin.tar.gz
+third_party/jacoco/*
+third_party/jacoco.tar.gz
 third_party/jasmin.tar.gz
 third_party/jasmin
 third_party/jdwp-tests.tar.gz
diff --git a/build.gradle b/build.gradle
index cfaacdb..b3846fb 100644
--- a/build.gradle
+++ b/build.gradle
@@ -283,6 +283,7 @@
                 "proguard/proguard6.0.1",
                 "gradle/gradle",
                 "jdwp-tests",
+                "jacoco",
                 "jasmin",
                 "jctf",
                 "kotlin",
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 3dbaa56..4f26b86 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.4.2-dev";
+  public static final String LABEL = "1.4.3-dev";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java b/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
index 22bbf46..dbfcbf2 100644
--- a/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.StackValue;
+import com.android.tools.r8.ir.code.StackValues;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator;
 import com.android.tools.r8.ir.regalloc.LiveIntervals;
@@ -116,7 +117,9 @@
       Instruction next = it.next();
       Value outValue = next.outValue();
       if (outValue != null) {
-        outValue.setNeedsRegister(!(outValue instanceof StackValue));
+        boolean isStackValue =
+            (outValue instanceof StackValue) || (outValue instanceof StackValues);
+        outValue.setNeedsRegister(!isStackValue);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Dup.java b/src/main/java/com/android/tools/r8/ir/code/Dup.java
new file mode 100644
index 0000000..1f2e418
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/code/Dup.java
@@ -0,0 +1,70 @@
+// 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.ir.code;
+
+import com.android.tools.r8.cf.LoadStoreHelper;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.conversion.CfBuilder;
+import com.android.tools.r8.ir.conversion.DexBuilder;
+import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
+
+public class Dup extends Instruction {
+
+  public Dup(StackValues dest, StackValue src) {
+    super(dest, src);
+  }
+
+  @Override
+  public void buildDex(DexBuilder builder) {
+    throw new Unreachable("This classfile-specific IR should not be inserted in the Dex backend.");
+  }
+
+  @Override
+  public void buildCf(CfBuilder builder) {
+    if (this.inValues.get(0).type == ValueType.LONG_OR_DOUBLE) {
+      builder.add(new CfStackInstruction(Opcode.Dup2));
+    } else {
+      builder.add(new CfStackInstruction(Opcode.Dup));
+    }
+  }
+
+  @Override
+  public boolean identicalNonValueNonPositionParts(Instruction other) {
+    return false;
+  }
+
+  @Override
+  public int compareNonValueParts(Instruction other) {
+    return 0;
+  }
+
+  @Override
+  public int maxInValueRegister() {
+    return 0;
+  }
+
+  @Override
+  public int maxOutValueRegister() {
+    throw new Unreachable();
+  }
+
+  @Override
+  public ConstraintWithTarget inliningConstraint(
+      InliningConstraints inliningConstraints, DexType invocationContext) {
+    return inliningConstraints.forDup();
+  }
+
+  @Override
+  public void insertLoadAndStores(InstructionListIterator it, LoadStoreHelper helper) {}
+
+  @Override
+  public boolean hasInvariantOutType() {
+    return false;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/code/StackValues.java b/src/main/java/com/android/tools/r8/ir/code/StackValues.java
new file mode 100644
index 0000000..475572e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/code/StackValues.java
@@ -0,0 +1,50 @@
+// 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.ir.code;
+
+import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
+import java.util.List;
+
+/**
+ * {@link StackValues} allow us to represent stack operations that produces two or more elements on
+ * the stack while using the same logic for instructions.
+ */
+public class StackValues extends Value {
+
+  private final int height;
+  private final List<StackValue> stackValues;
+
+  public StackValues(TypeLatticeElement typeLattice, int height, List<StackValue> stackValues) {
+    super(Value.UNDEFINED_NUMBER, typeLattice, null);
+    this.height = height;
+    this.stackValues = stackValues;
+    assert height >= 0;
+    assert stackValues.size() >= 2;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  public List<StackValue> getStackValues() {
+    return stackValues;
+  }
+
+  @Override
+  public boolean needsRegister() {
+    return false;
+  }
+
+  @Override
+  public void setNeedsRegister(boolean value) {
+    assert !value;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    return String.format("s%d+%d", height, stackValues.size() - 1);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index 8816326..ea6cac0 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -36,6 +36,7 @@
 import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.StackValue;
+import com.android.tools.r8.ir.code.StackValues;
 import com.android.tools.r8.ir.code.Store;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.CodeRewriter;
@@ -363,6 +364,11 @@
         if (outValue instanceof StackValue) {
           stack.push(outValue);
         }
+        if (outValue instanceof StackValues) {
+          for (StackValue outVal : ((StackValues) outValue).getStackValues()) {
+            stack.push(outVal);
+          }
+        }
       }
       if (instruction.isDebugLocalsChange()) {
         if (instruction.asDebugLocalsChange().apply(pendingLocals)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
index de657de..7130516 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -94,6 +94,10 @@
     return ConstraintWithTarget.ALWAYS;
   }
 
+  public ConstraintWithTarget forDup() {
+    return ConstraintWithTarget.ALWAYS;
+  }
+
   public ConstraintWithTarget forInstanceGet(DexField field, DexType invocationContext) {
     DexField lookup = graphLense.lookupField(field);
     return forFieldInstruction(
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index 9345bb9..d98496e 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -26,6 +26,8 @@
 import com.android.tools.r8.ir.code.NumericType;
 import com.android.tools.r8.ir.code.Or;
 import com.android.tools.r8.ir.code.Phi;
+import com.android.tools.r8.ir.code.StackValue;
+import com.android.tools.r8.ir.code.StackValues;
 import com.android.tools.r8.ir.code.Sub;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.Xor;
@@ -2520,7 +2522,11 @@
           // For instructions that define values which have no use create a live range covering
           // the instruction. This will typically be instructions that can have side effects even
           // if their output is not used.
-          if (!definition.isUsed()) {
+          if (definition instanceof StackValues) {
+            for (StackValue value : ((StackValues) definition).getStackValues()) {
+              live.remove(value);
+            }
+          } else if (!definition.isUsed()) {
             addLiveRange(
                 definition,
                 block,
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 d83ad75..65d1e3a 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -582,9 +582,7 @@
   //
   // See b/116683601 and b/116837585.
   public boolean canHaveThisJitCodeDebuggingBug() {
-    // TODO(b/116841249): Make this an actual min-sdk guard once we know that Art no longer crashes
-    // on these accesses.
-    return true;
+    return minApiLevel < AndroidApiLevel.Q.getLevel();
   }
 
   // The dalvik jit had a bug where the long operations add, sub, or, xor and and would write
diff --git a/src/test/java/com/android/tools/r8/D8TestBuilder.java b/src/test/java/com/android/tools/r8/D8TestBuilder.java
index 368e8e4..21a5e0e 100644
--- a/src/test/java/com/android/tools/r8/D8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/D8TestBuilder.java
@@ -5,9 +5,11 @@
 
 import com.android.tools.r8.D8Command.Builder;
 import com.android.tools.r8.TestBase.Backend;
+import com.android.tools.r8.utils.InternalOptions;
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.function.Consumer;
 
 public class D8TestBuilder extends TestCompilerBuilder<D8Command, Builder, D8TestBuilder> {
 
@@ -28,8 +30,9 @@
   }
 
   @Override
-  void internalCompile(Builder builder) throws CompilationFailedException {
-    D8.run(builder.build());
+  void internalCompile(Builder builder, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationFailedException {
+    ToolHelper.runD8(builder, optionsConsumer);
   }
 
   public D8TestBuilder addClasspathClasses(Class<?>... classes) {
diff --git a/src/test/java/com/android/tools/r8/JacocoRegressionTest.java b/src/test/java/com/android/tools/r8/JacocoRegressionTest.java
new file mode 100644
index 0000000..235b7c6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/JacocoRegressionTest.java
@@ -0,0 +1,115 @@
+// 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.nio.file.Path;
+import org.junit.Test;
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/** Jacoco does invalid instrumentation when R8 clobber locals of arguments: TODO(b/117589870) */
+public class JacocoRegressionTest extends TestBase implements Opcodes {
+
+  @Test
+  public void test() throws Exception {
+    Path output = temp.newFolder().toPath();
+    String name = "Test";
+    String desc = DescriptorUtils.javaTypeToDescriptor(name);
+    byte[] bytes = dump();
+    Path path = output.resolve("out.jar");
+    ArchiveConsumer archiveConsumer = new ArchiveConsumer(path);
+    archiveConsumer.accept(ByteDataView.of(bytes), desc, null);
+    archiveConsumer.finished(null);
+
+    String expected = "15" + System.lineSeparator();
+    ProcessResult result = ToolHelper.runJava(path, name);
+    assertEquals(expected, result.stdout);
+
+    Path agentOutput = output.resolve("agent.out");
+    ProcessResult result1 =
+        ToolHelper.runJava(
+            path,
+            String.format(
+                "-javaagent:%s=destfile=%s,dumponexit=true,output=file",
+                ToolHelper.JACOCO_AGENT, agentOutput),
+            name);
+    assertEquals(1, result1.exitCode);
+    assertTrue(result1.toString().contains("java.lang.VerifyError: Bad local variable type"));
+  }
+
+  public static byte[] dump() throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    FieldVisitor fieldVisitor;
+    MethodVisitor methodVisitor;
+    AnnotationVisitor annotationVisitor0;
+
+    classWriter.visit(
+        V1_8, ACC_FINAL | ACC_SUPER | ACC_PUBLIC, "Test", null, "java/lang/Object", null);
+    classWriter.visitSource("Test.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PRIVATE, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(32, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLocalVariable("this", "LTest;", null, label0, label1, 0);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+
+    // This is the problematic part for Jacoco, where we clobber local 1 with long_2nd
+    {
+      methodVisitor = classWriter.visitMethod(ACC_STATIC, "foo", "(I)I", null, null);
+      methodVisitor.visitCode();
+      methodVisitor.visitVarInsn(ILOAD, 0);
+      methodVisitor.visitInsn(I2L);
+      methodVisitor.visitVarInsn(LSTORE, 0);
+      methodVisitor.visitIntInsn(BIPUSH, 15);
+      methodVisitor.visitInsn(IRETURN);
+      methodVisitor.visitMaxs(4, 4);
+      methodVisitor.visitEnd();
+    }
+
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(6, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitIntInsn(BIPUSH, 42);
+      methodVisitor.visitMethodInsn(INVOKESTATIC, "Test", "foo", "(I)I", false);
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(I)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(7, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 50e659c..74b40b0 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -6,10 +6,13 @@
 import com.android.tools.r8.R8Command.Builder;
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
 
 public class R8TestBuilder extends TestCompilerBuilder<R8Command, Builder, R8TestBuilder> {
 
@@ -32,11 +35,17 @@
   }
 
   @Override
-  public void internalCompile(Builder builder) throws CompilationFailedException {
+  void internalCompile(Builder builder, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationFailedException {
     if (enableInliningAnnotations) {
       ToolHelper.allowTestProguardOptions(builder);
     }
-    R8.run(builder.build());
+    ToolHelper.runR8WithoutResult(builder.build(), optionsConsumer);
+  }
+
+  public R8TestBuilder addDataResources(List<DataEntryResource> resources) {
+    resources.forEach(builder.getAppBuilder()::addDataResource);
+    return self();
   }
 
   public R8TestBuilder addKeepRules(String... rules) {
@@ -81,4 +90,9 @@
     }
     return self();
   }
+
+  public R8TestBuilder enableProguardTestOptions() {
+    builder.allowTestProguardOptions();
+    return self();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index efec188..5c6abba 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -736,7 +736,7 @@
     }
   }
 
-  private String extractClassName(byte[] ccc) {
+  public String extractClassName(byte[] ccc) {
     class ClassNameExtractor extends ClassVisitor {
       private String className;
 
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index 9996dde..4e7cf37 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -7,8 +7,10 @@
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
 import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
 
 public class TestCompileResult {
   private final TestState state;
@@ -32,6 +34,10 @@
     }
   }
 
+  public CodeInspector inspector() throws IOException, ExecutionException {
+    return new CodeInspector(app);
+  }
+
   private TestRunResult runJava(String mainClass) throws IOException {
     Path out = state.getNewTempFolder().resolve("out.zip");
     app.writeToZip(out, OutputMode.ClassFile);
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index c6af2c7..db25352 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -6,9 +6,11 @@
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidAppConsumers;
+import com.android.tools.r8.utils.InternalOptions;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
+import java.util.function.Consumer;
 
 public abstract class TestCompilerBuilder<
         C extends BaseCompilerCommand,
@@ -16,6 +18,12 @@
         T extends TestCompilerBuilder<C, B, T>>
     extends TestBuilder<T> {
 
+  public static final Consumer<InternalOptions> DEFAULT_OPTIONS =
+      new Consumer<InternalOptions>() {
+        @Override
+        public void accept(InternalOptions options) {}
+      };
+
   private final B builder;
   private final Backend backend;
 
@@ -23,6 +31,7 @@
   private Path defaultLibrary;
   private ProgramConsumer programConsumer;
   private AndroidApiLevel defaultMinApiLevel = ToolHelper.getMinApiLevelForDexVm();
+  private Consumer<InternalOptions> optionsConsumer = DEFAULT_OPTIONS;
 
   TestCompilerBuilder(TestState state, B builder, Backend backend) {
     super(state);
@@ -34,7 +43,13 @@
 
   abstract T self();
 
-  abstract void internalCompile(B builder) throws CompilationFailedException;
+  abstract void internalCompile(B builder, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationFailedException;
+
+  public T addOptionsModification(Consumer<InternalOptions> optionsConsumer) {
+    this.optionsConsumer = this.optionsConsumer.andThen(optionsConsumer);
+    return self();
+  }
 
   public TestCompileResult compile() throws CompilationFailedException {
     AndroidAppConsumers sink = new AndroidAppConsumers();
@@ -45,7 +60,7 @@
     if (backend == Backend.DEX && defaultMinApiLevel != null) {
       builder.setMinApiLevel(defaultMinApiLevel.getLevel());
     }
-    internalCompile(builder);
+    internalCompile(builder, optionsConsumer);
     return new TestCompileResult(getState(), backend, sink.build());
   }
 
diff --git a/src/test/java/com/android/tools/r8/TestRunResult.java b/src/test/java/com/android/tools/r8/TestRunResult.java
index fcaed49..2a94188 100644
--- a/src/test/java/com/android/tools/r8/TestRunResult.java
+++ b/src/test/java/com/android/tools/r8/TestRunResult.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
+import java.io.PrintStream;
 import java.util.concurrent.ExecutionException;
 
 public class TestRunResult {
@@ -48,22 +49,43 @@
 
   private String errorMessage(String message) {
     StringBuilder builder = new StringBuilder(message).append('\n');
-    printInfo(builder);
+    appendInfo(builder);
     return builder.toString();
   }
 
-  private void printInfo(StringBuilder builder) {
+  private void appendInfo(StringBuilder builder) {
     builder.append("APPLICATION: ");
-    printApplication(builder);
+    appendApplication(builder);
     builder.append('\n');
-    printProcessResult(builder);
+    appendProcessResult(builder);
   }
 
-  private void printApplication(StringBuilder builder) {
+  private void appendApplication(StringBuilder builder) {
     builder.append(app == null ? "<default>" : app.toString());
   }
 
-  private void printProcessResult(StringBuilder builder) {
+  private void appendProcessResult(StringBuilder builder) {
     builder.append("COMMAND: ").append(result.command).append('\n').append(result);
   }
+
+  public TestRunResult writeInfo(PrintStream ps) {
+    StringBuilder sb = new StringBuilder();
+    appendInfo(sb);
+    ps.println(sb.toString());
+    return this;
+  }
+
+  public TestRunResult writeApplicaion(PrintStream ps) {
+    StringBuilder sb = new StringBuilder();
+    appendApplication(sb);
+    ps.println(sb.toString());
+    return this;
+  }
+
+  public TestRunResult writeProcessResult(PrintStream ps) {
+    StringBuilder sb = new StringBuilder();
+    appendProcessResult(sb);
+    ps.println(sb.toString());
+    return this;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 8ae0dad..692a6fa 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -104,6 +104,7 @@
   private static final String PROGUARD5_2_1 = "third_party/proguard/proguard5.2.1/bin/proguard";
   private static final String PROGUARD6_0_1 = "third_party/proguard/proguard6.0.1/bin/proguard";
   private static final String PROGUARD = PROGUARD5_2_1;
+  public static final String JACOCO_AGENT = "third_party/jacoco/org.jacoco.agent-0.8.2-runtime.jar";
 
   private static final String RETRACE6_0_1 = "third_party/proguard/proguard6.0.1/bin/retrace";
   private static final String RETRACE = RETRACE6_0_1;
@@ -760,7 +761,7 @@
     while (enclosing.getEnclosingClass() != null) {
       parts.set(parts.size() - 2, parts.get(parts.size() - 2) + "$" + parts.get(parts.size() - 1));
       parts.remove(parts.size() - 1);
-      enclosing = clazz.getEnclosingClass();
+      enclosing = enclosing.getEnclosingClass();
     }
     parts.set(parts.size() - 1, parts.get(parts.size() - 1) + ".class");
     return parts;
@@ -875,6 +876,14 @@
     return runR8WithFullResult(command, optionsConsumer);
   }
 
+  public static void runR8WithoutResult(
+      R8Command command, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationFailedException {
+    InternalOptions internalOptions = command.getInternalOptions();
+    optionsConsumer.accept(internalOptions);
+    R8.runForTesting(command.getInputApp(), internalOptions);
+  }
+
   public static AndroidApp runR8WithFullResult(
       R8Command command, Consumer<InternalOptions> optionsConsumer)
       throws CompilationFailedException {
@@ -932,6 +941,14 @@
     return compatSink.build();
   }
 
+  public static void runD8WithoutResult(
+      D8Command command, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationFailedException {
+    InternalOptions internalOptions = command.getInternalOptions();
+    optionsConsumer.accept(internalOptions);
+    D8.runForTesting(command.getInputApp(), internalOptions);
+  }
+
   public static AndroidApp runDexer(String fileName, String outDir, String... extraArgs)
       throws IOException {
     List<String> args = new ArrayList<>();
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index b6cdb48..445dd53 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongList;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
@@ -508,6 +509,15 @@
     return t -> inspector.accept(t.debuggeeState);
   }
 
+  protected final JUnit3Wrapper.Command conditional(
+      Function<JUnit3Wrapper.DebuggeeState, List<JUnit3Wrapper.Command>> conditional) {
+    return t -> subcommands(conditional.apply(t.debuggeeState)).perform(t);
+  }
+
+  protected final JUnit3Wrapper.Command subcommands(List<JUnit3Wrapper.Command> commands) {
+    return t -> Lists.reverse(commands).forEach(t.commandsQueue::addFirst);
+  }
+
   protected final JUnit3Wrapper.Command setLocal(String localName, Value newValue) {
     return new JUnit3Wrapper.Command.SetLocalCommand(localName, newValue);
   }
diff --git a/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest.java b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest.java
new file mode 100644
index 0000000..027d709
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest.java
@@ -0,0 +1,20 @@
+// 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.debug;
+
+import java.util.Collection;
+import java.util.List;
+
+public class StepIntoMethodWithTypeParameterArgumentsTest {
+
+  public static List<Object> field = null;
+
+  public static void foo(List<String> strings) {
+    Collection<Object> objects = field;
+  }
+
+  public static void main(String[] args) {
+    foo(null);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestDump.java b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestDump.java
new file mode 100644
index 0000000..ef1cab1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestDump.java
@@ -0,0 +1,153 @@
+// 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.debug;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class StepIntoMethodWithTypeParameterArgumentsTestDump implements Opcodes {
+
+  public static byte[] dump(boolean moveFirstLineEntry) {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    FieldVisitor fieldVisitor;
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(
+        V1_8,
+        ACC_PUBLIC | ACC_SUPER,
+        "com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest",
+        null,
+        "java/lang/Object",
+        null);
+
+    classWriter.visitSource("StepIntoMethodWithTypeParameterArgumentsTest.java", null);
+
+    {
+      fieldVisitor =
+          classWriter.visitField(
+              ACC_PUBLIC | ACC_STATIC,
+              "field",
+              "Ljava/util/List;",
+              "Ljava/util/List<Ljava/lang/Object;>;",
+              null);
+      fieldVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(9, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLocalVariable(
+          "this",
+          "Lcom/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest;",
+          null,
+          label0,
+          label1,
+          0);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC,
+              "foo",
+              "(Ljava/util/List;)V",
+              "(Ljava/util/List<Ljava/lang/String;>;)V",
+              null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      if (!moveFirstLineEntry) {
+        // Removed to have 'strings' start at undefined line number.
+        methodVisitor.visitLineNumber(14, label0);
+      }
+      methodVisitor.visitFieldInsn(
+          GETSTATIC,
+          "com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest",
+          "field",
+          "Ljava/util/List;");
+      methodVisitor.visitVarInsn(ASTORE, 1);
+      if (moveFirstLineEntry) {
+        // Move the line entry to after 'strings' has already become live.
+        Label labelNop = new Label();
+        methodVisitor.visitLabel(labelNop);
+        methodVisitor.visitLineNumber(14, labelNop);
+        methodVisitor.visitInsn(NOP);
+      }
+      // Now at line 13 objects will be live.
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(15, label1);
+      methodVisitor.visitInsn(RETURN);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLocalVariable(
+          "strings", "Ljava/util/List;", "Ljava/util/List<Ljava/lang/String;>;", label0, label2, 0);
+      methodVisitor.visitLocalVariable(
+          "objects",
+          "Ljava/util/Collection;",
+          "Ljava/util/Collection<Ljava/lang/Object;>;",
+          label1,
+          label2,
+          1);
+      methodVisitor.visitMaxs(1, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(18, label0);
+      methodVisitor.visitInsn(ACONST_NULL);
+      methodVisitor.visitMethodInsn(
+          INVOKESTATIC,
+          "com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest",
+          "foo",
+          "(Ljava/util/List;)V",
+          false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(19, label1);
+      methodVisitor.visitInsn(RETURN);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLocalVariable("args", "[Ljava/lang/String;", null, label0, label2, 0);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(11, label0);
+      methodVisitor.visitInsn(ACONST_NULL);
+      methodVisitor.visitFieldInsn(
+          PUTSTATIC,
+          "com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTest",
+          "field",
+          "Ljava/util/List;");
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 0);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestRunner.java b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestRunner.java
new file mode 100644
index 0000000..aa4542a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/StepIntoMethodWithTypeParameterArgumentsTestRunner.java
@@ -0,0 +1,73 @@
+// 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.debug;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.D8;
+import com.android.tools.r8.D8Command;
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import org.junit.Test;
+
+/** Tests debugging behavior with regards to exception handling */
+public class StepIntoMethodWithTypeParameterArgumentsTestRunner extends DebugTestBase {
+
+  private static final Class CLASS = StepIntoMethodWithTypeParameterArgumentsTest.class;
+  private static final String NAME = CLASS.getCanonicalName();
+  private static final String DESC = DescriptorUtils.javaTypeToDescriptor(NAME);
+  private static final String FILE = CLASS.getSimpleName() + ".java";
+
+  @Test
+  public void testCf() throws Throwable {
+    byte[] bytes = StepIntoMethodWithTypeParameterArgumentsTestDump.dump(true);
+    assertEquals(NAME, extractClassName(bytes));
+    // Java jumps to first instruction of the catch handler, matching the source code.
+    Path jar = temp.getRoot().toPath().resolve("test.jar");
+    ArchiveConsumer archiveConsumer = new ArchiveConsumer(jar);
+    archiveConsumer.accept(ByteDataView.of(bytes), DESC, null);
+    archiveConsumer.finished(null);
+    run(new CfDebugTestConfig().addPaths(jar));
+  }
+
+  @Test
+  public void testD8() throws Throwable {
+    Path out = temp.getRoot().toPath().resolve("out.jar");
+    D8.run(
+        D8Command.builder()
+            .addClassProgramData(
+                StepIntoMethodWithTypeParameterArgumentsTestDump.dump(true), Origin.unknown())
+            .setOutput(out, OutputMode.DexIndexed)
+            .build());
+    run(new DexDebugTestConfig().addPaths(out));
+  }
+
+  private void run(DebugTestConfig config) throws Throwable {
+    runDebugTest(
+        config,
+        NAME,
+        breakpoint(NAME, "main"),
+        run(),
+        checkLine(FILE, 18), // First line in main.
+        stepInto(),
+        checkLine(FILE, -1), // First line in foo is undefined due to ASM dump change.
+        checkLocal("strings"),
+        checkNoLocal("objects"),
+        stepOver(),
+        // Step will skip line 14 and hit 15 on JVM but will (correctly?) hit 14 on Art.
+        subcommands(
+            config instanceof CfDebugTestConfig
+                ? ImmutableList.of()
+                : ImmutableList.of(checkLine(FILE, 14), stepOver())),
+        checkLine(FILE, 15),
+        checkLocal("strings"),
+        checkLocal("objects"),
+        run());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/AdaptResourceFileContentsTest.java b/src/test/java/com/android/tools/r8/naming/AdaptResourceFileContentsTest.java
index 9ba82a9..b03c257 100644
--- a/src/test/java/com/android/tools/r8/naming/AdaptResourceFileContentsTest.java
+++ b/src/test/java/com/android/tools/r8/naming/AdaptResourceFileContentsTest.java
@@ -17,19 +17,16 @@
 import com.android.tools.r8.DataResourceConsumer;
 import com.android.tools.r8.DataResourceProvider.Visitor;
 import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestCompileResult;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.forceproguardcompatibility.ProguardCompatibilityTestBase;
-import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.ArchiveResourceProvider;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.ByteStreams;
 import java.io.File;
-import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Path;
 import java.util.Arrays;
@@ -47,6 +44,12 @@
 @RunWith(Parameterized.class)
 public class AdaptResourceFileContentsTest extends ProguardCompatibilityTestBase {
 
+  private static final List<Class<?>> CLASSES =
+      ImmutableList.of(
+          AdaptResourceFileContentsTestClass.class,
+          AdaptResourceFileContentsTestClass.A.class,
+          AdaptResourceFileContentsTestClass.B.class);
+
   private Backend backend;
 
   @Parameterized.Parameters(name = "Backend: {0}")
@@ -171,9 +174,9 @@
 
   @Test
   public void testEnabled() throws Exception {
+    String pgConf = getProguardConfigWithNeverInline(true, null);
     CustomDataResourceConsumer dataResourceConsumer = new CustomDataResourceConsumer();
-    AndroidApp out =
-        compileWithR8(getProguardConfigWithNeverInline(true, null), dataResourceConsumer);
+    CodeInspector inspector = compileWithR8(pgConf, dataResourceConsumer).inspector();
 
     // Check that the data resources have changed as expected.
     checkAllAreChanged(
@@ -182,8 +185,7 @@
         dataResourceConsumer.get("resource-all-changed.txt"), originalAllChangedResource);
 
     // Check that the new names are consistent with the actual application code.
-    checkAllArePresent(
-        dataResourceConsumer.get("resource-all-present.txt"), new CodeInspector(out));
+    checkAllArePresent(dataResourceConsumer.get("resource-all-present.txt"), inspector);
 
     // Check that the data resources have not changed unexpectedly.
     checkAllAreUnchanged(
@@ -315,32 +317,22 @@
     }
   }
 
-  private AndroidApp compileWithR8(String proguardConfig, DataResourceConsumer dataResourceConsumer)
-      throws CompilationFailedException, IOException {
-    R8Command command =
-        ToolHelper.allowTestProguardOptions(
-                ToolHelper.prepareR8CommandBuilder(getAndroidApp(), emptyConsumer(backend))
-                    .addProguardConfiguration(ImmutableList.of(proguardConfig), Origin.unknown()))
-            .addLibraryFiles(runtimeJar(backend))
-            .build();
-    return ToolHelper.runR8(
-        command,
-        options -> {
-          // TODO(christofferqa): Class inliner should respect -neverinline.
-          options.enableClassInlining = false;
-          options.enableVerticalClassMerging = true;
-          options.dataResourceConsumer = dataResourceConsumer;
-        });
-  }
-
-  private AndroidApp getAndroidApp() throws IOException {
-    AndroidApp.Builder builder = AndroidApp.builder();
-    builder.addProgramFiles(
-        ToolHelper.getClassFileForTestClass(AdaptResourceFileContentsTestClass.class),
-        ToolHelper.getClassFileForTestClass(AdaptResourceFileContentsTestClass.A.class),
-        ToolHelper.getClassFileForTestClass(AdaptResourceFileContentsTestClass.B.class));
-    getDataResources().forEach(builder::addDataResource);
-    return builder.build();
+  private TestCompileResult compileWithR8(
+      String proguardConfig, DataResourceConsumer dataResourceConsumer)
+      throws CompilationFailedException {
+    return testForR8(backend)
+        .addProgramClasses(CLASSES)
+        .addDataResources(getDataResources())
+        .enableProguardTestOptions()
+        .addKeepRules(proguardConfig)
+        .addOptionsModification(
+            o -> {
+              // TODO(christofferqa): Class inliner should respect -neverinline.
+              o.enableClassInlining = false;
+              o.enableVerticalClassMerging = true;
+              o.dataResourceConsumer = dataResourceConsumer;
+            })
+        .compile();
   }
 
   private List<DataEntryResource> getDataResources() {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
index b026c31..57ad556 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
@@ -58,9 +58,6 @@
   }
 }
 
-// TODO(b/110141157):
-// - Add tests where fields and methods get renamed due to naming conflicts.
-// - Add tests where the then-clause of an -if rule keeps a class that has been merged into another.
 @RunWith(Parameterized.class)
 public class IfRuleWithVerticalClassMerging extends TestBase {
 
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
index a877fec..7c85a7b 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
@@ -4,6 +4,16 @@
 
 package com.android.tools.r8.shaking.ifrule.verticalclassmerging;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+
 public class MergedFieldTypeTest extends MergedTypeBaseTest {
 
   static class TestClass {
@@ -33,4 +43,69 @@
   public String getExpectedStdout() {
     return B.class.getName();
   }
+
+  public static class MergedFieldTypeWithCollisionTest extends MergedTypeBaseTest {
+
+    static class SuperTestClass {
+
+      private A field = new B();
+
+      public A get() {
+        return field;
+      }
+    }
+
+    static class TestClass extends SuperTestClass {
+
+      private A field = null;
+
+      public static void main(String[] args) {
+        TestClass obj = new TestClass();
+        if (false) {
+          obj.field = new B();
+          System.out.println(obj.field);
+        }
+        System.out.print(obj.get().getClass().getName());
+      }
+    }
+
+    public MergedFieldTypeWithCollisionTest(Backend backend, boolean enableVerticalClassMerging) {
+      super(backend, enableVerticalClassMerging, ImmutableList.of(SuperTestClass.class));
+    }
+
+    @Override
+    public Class<?> getTestClass() {
+      return TestClass.class;
+    }
+
+    @Override
+    public String getConditionForProguardIfRule() {
+      return "-if class **$SuperTestClass { **$A field; }";
+    }
+
+    @Override
+    public String getExpectedStdout() {
+      return B.class.getName();
+    }
+
+    @Override
+    public void inspect(CodeInspector inspector) {
+      super.inspect(inspector);
+
+      ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+      assertThat(testClassSubject, isPresent());
+
+      if (enableVerticalClassMerging) {
+        // Verify that SuperTestClass has been merged into TestClass.
+        assertThat(inspector.clazz(SuperTestClass.class), not(isPresent()));
+        assertEquals("java.lang.Object", testClassSubject.getDexClass().superType.toSourceString());
+
+        // Verify that TestClass.field has been removed.
+        assertEquals(1, testClassSubject.allFields().size());
+
+        // Verify that there was a naming conflict such that SuperTestClass.field was renamed.
+        assertNotEquals("field", testClassSubject.allFields().get(0).getFinalName());
+      }
+    }
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
index 7447efd1..d8c1f29 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
@@ -4,6 +4,19 @@
 
 package com.android.tools.r8.shaking.ifrule.verticalclassmerging;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class MergedParameterTypeTest extends MergedTypeBaseTest {
 
   static class TestClass {
@@ -35,4 +48,73 @@
   public String getExpectedStdout() {
     return B.class.getName();
   }
+
+  public static class MergedParameterTypeWithCollisionTest extends MergedTypeBaseTest {
+
+    static class SuperTestClass {
+
+      public static void method(A obj) {
+        System.out.print(obj.getClass().getName());
+      }
+    }
+
+    static class TestClass extends SuperTestClass {
+
+      public static void main(String[] args) {
+        B obj = new B();
+        if (obj == null) {
+          TestClass.method(obj);
+        }
+        SuperTestClass.method(obj);
+      }
+
+      public static void method(A obj) {
+        System.out.print(obj.getClass().getName());
+      }
+    }
+
+    public MergedParameterTypeWithCollisionTest(
+        Backend backend, boolean enableVerticalClassMerging) {
+      super(backend, enableVerticalClassMerging, ImmutableList.of(SuperTestClass.class));
+    }
+
+    @Override
+    public Class<?> getTestClass() {
+      return TestClass.class;
+    }
+
+    @Override
+    public String getConditionForProguardIfRule() {
+      return "-if class **$SuperTestClass { void method(**$A); }";
+    }
+
+    @Override
+    public String getExpectedStdout() {
+      return B.class.getName();
+    }
+
+    @Override
+    public void inspect(CodeInspector inspector) {
+      super.inspect(inspector);
+
+      ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+      assertThat(testClassSubject, isPresent());
+
+      if (enableVerticalClassMerging) {
+        // Verify that SuperTestClass has been merged into TestClass.
+        assertThat(inspector.clazz(SuperTestClass.class), not(isPresent()));
+        assertEquals("java.lang.Object", testClassSubject.getDexClass().superType.toSourceString());
+
+        // Verify that TestClass.method has been removed.
+        List<FoundMethodSubject> methods =
+            testClassSubject.allMethods().stream()
+                .filter(subject -> subject.getFinalName().contains("method"))
+                .collect(Collectors.toList());
+        assertEquals(1, methods.size());
+
+        // Verify that there was a naming conflict such that SuperTestClass.method was renamed.
+        assertNotEquals("method", methods.get(0).getFinalName());
+      }
+    }
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
index da4a9f1..e1b071f 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
@@ -4,6 +4,19 @@
 
 package com.android.tools.r8.shaking.ifrule.verticalclassmerging;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class MergedReturnTypeTest extends MergedTypeBaseTest {
 
   static class TestClass {
@@ -35,4 +48,72 @@
   public String getExpectedStdout() {
     return B.class.getName();
   }
+
+  public static class MergedReturnTypeWithCollisionTest extends MergedTypeBaseTest {
+
+    static class SuperTestClass {
+
+      public static A method() {
+        return new B();
+      }
+    }
+
+    static class TestClass extends SuperTestClass {
+
+      public static void main(String[] args) {
+        B obj = new B();
+        if (obj == null) {
+          System.out.print(TestClass.method().getClass().getName());
+        }
+        System.out.print(SuperTestClass.method().getClass().getName());
+      }
+
+      public static A method() {
+        return new B();
+      }
+    }
+
+    public MergedReturnTypeWithCollisionTest(Backend backend, boolean enableVerticalClassMerging) {
+      super(backend, enableVerticalClassMerging, ImmutableList.of(SuperTestClass.class));
+    }
+
+    @Override
+    public Class<?> getTestClass() {
+      return TestClass.class;
+    }
+
+    @Override
+    public String getConditionForProguardIfRule() {
+      return "-if class **$SuperTestClass { **$A method(); }";
+    }
+
+    @Override
+    public String getExpectedStdout() {
+      return B.class.getName();
+    }
+
+    @Override
+    public void inspect(CodeInspector inspector) {
+      super.inspect(inspector);
+
+      ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+      assertThat(testClassSubject, isPresent());
+
+      if (enableVerticalClassMerging) {
+        // Verify that SuperTestClass has been merged into TestClass.
+        assertThat(inspector.clazz(SuperTestClass.class), not(isPresent()));
+        assertEquals("java.lang.Object", testClassSubject.getDexClass().superType.toSourceString());
+
+        // Verify that TestClass.method has been removed.
+        List<FoundMethodSubject> methods =
+            testClassSubject.allMethods().stream()
+                .filter(subject -> subject.getFinalName().contains("method"))
+                .collect(Collectors.toList());
+        assertEquals(1, methods.size());
+
+        // Verify that there was a naming conflict such that SuperTestClass.method was renamed.
+        assertNotEquals("method", methods.get(0).getFinalName());
+      }
+    }
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedTypeBaseTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedTypeBaseTest.java
index ac341eb..cda8096 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedTypeBaseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedTypeBaseTest.java
@@ -27,10 +27,6 @@
 @RunWith(Parameterized.class)
 public abstract class MergedTypeBaseTest extends TestBase {
 
-  private final List<Class> CLASSES =
-      ImmutableList.of(
-          A.class, B.class, C.class, I.class, J.class, K.class, Unused.class, getTestClass());
-
   static class A {}
 
   static class B extends A {}
@@ -46,11 +42,22 @@
   static class Unused {}
 
   final Backend backend;
+  final List<Class> classes;
   final boolean enableVerticalClassMerging;
 
   public MergedTypeBaseTest(Backend backend, boolean enableVerticalClassMerging) {
+    this(backend, enableVerticalClassMerging, ImmutableList.of());
+  }
+
+  public MergedTypeBaseTest(
+      Backend backend, boolean enableVerticalClassMerging, List<Class<?>> additionalClasses) {
     this.backend = backend;
     this.enableVerticalClassMerging = enableVerticalClassMerging;
+    this.classes =
+        ImmutableList.<Class>builder()
+            .add(A.class, B.class, C.class, I.class, J.class, K.class, Unused.class, getTestClass())
+            .addAll(additionalClasses)
+            .build();
   }
 
   @Parameters(name = "Backend: {0}, vertical class merging: {1}")
@@ -96,7 +103,7 @@
             getConditionForProguardIfRule(),
             "-keep class " + Unused.class.getTypeName(),
             getAdditionalKeepRules());
-    AndroidApp output = compileWithR8(readClasses(CLASSES), config, this::configure, backend);
+    AndroidApp output = compileWithR8(readClasses(classes), config, this::configure, backend);
     assertEquals(expected, runOnVM(output, getTestClass(), backend));
     inspect(new CodeInspector(output));
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index 90013b0..e76991b 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -56,6 +56,12 @@
 
   public abstract void forAllFields(Consumer<FoundFieldSubject> inspection);
 
+  public final List<FoundFieldSubject> allFields() {
+    ImmutableList.Builder<FoundFieldSubject> builder = ImmutableList.builder();
+    forAllFields(builder::add);
+    return builder.build();
+  }
+
   public abstract FieldSubject field(String type, String name);
 
   public FoundClassSubject asFoundClassSubject() {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 1d308fc..ed71b96 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -20,7 +20,6 @@
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.signature.GenericSignatureParser;
 import com.android.tools.r8.utils.DescriptorUtils;
-import com.google.common.collect.ImmutableList;
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -109,12 +108,6 @@
         inspection);
   }
 
-  public List<FoundFieldSubject> allFields() {
-    ImmutableList.Builder<FoundFieldSubject> builder = ImmutableList.builder();
-    forAllFields(builder::add);
-    return builder.build();
-  }
-
   @Override
   public FieldSubject field(String type, String name) {
     String obfuscatedType = codeInspector.getObfuscatedTypeName(type);
diff --git a/third_party/jacoco.tar.gz.sha1 b/third_party/jacoco.tar.gz.sha1
new file mode 100644
index 0000000..8a0462f
--- /dev/null
+++ b/third_party/jacoco.tar.gz.sha1
@@ -0,0 +1 @@
+b968df99f88434e2a2a35445ac860ee6a2fa16e3
\ No newline at end of file