diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
index b2e0f6d..22ad739 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
@@ -54,6 +54,7 @@
   private final DumpInputFlags dumpInputFlags;
   private final MapIdProvider mapIdProvider;
   private final SourceFileProvider sourceFileProvider;
+  private final ClassConflictResolver classConflictResolver;
 
   BaseCompilerCommand(boolean printHelp, boolean printVersion) {
     super(printHelp, printVersion);
@@ -72,6 +73,7 @@
     dumpInputFlags = DumpInputFlags.noDump();
     mapIdProvider = null;
     sourceFileProvider = null;
+    classConflictResolver = null;
   }
 
   BaseCompilerCommand(
@@ -90,7 +92,8 @@
       int threadCount,
       DumpInputFlags dumpInputFlags,
       MapIdProvider mapIdProvider,
-      SourceFileProvider sourceFileProvider) {
+      SourceFileProvider sourceFileProvider,
+      ClassConflictResolver classConflictResolver) {
     super(app);
     assert minApiLevel > 0;
     assert mode != null;
@@ -109,6 +112,7 @@
     this.dumpInputFlags = dumpInputFlags;
     this.mapIdProvider = mapIdProvider;
     this.sourceFileProvider = sourceFileProvider;
+    this.classConflictResolver = classConflictResolver;
   }
 
   /**
@@ -197,6 +201,10 @@
     return threadCount;
   }
 
+  ClassConflictResolver getClassConflictResolver() {
+    return classConflictResolver;
+  }
+
   DumpInputFlags getDumpInputFlags() {
     return dumpInputFlags;
   }
@@ -237,6 +245,7 @@
     private DumpInputFlags dumpInputFlags = DumpInputFlags.noDump();
     private MapIdProvider mapIdProvider = null;
     private SourceFileProvider sourceFileProvider = null;
+    private ClassConflictResolver classConflictResolver = null;
 
     abstract CompilationMode defaultCompilationMode();
 
@@ -720,5 +729,21 @@
     List<Consumer<Inspector>> getOutputInspections() {
       return outputInspections;
     }
+
+    /**
+     * Set a conflict resolver to determine which class definition to use in case of duplicates.
+     *
+     * <p>If no resolver is set, the compiler will fail compilation in case of duplicates.
+     *
+     * @param resolver Resolver for choosing between duplicate classes.
+     */
+    public B setClassConflictResolver(ClassConflictResolver resolver) {
+      this.classConflictResolver = resolver;
+      return self();
+    }
+
+    ClassConflictResolver getClassConflictResolver() {
+      return classConflictResolver;
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ClassConflictResolver.java b/src/main/java/com/android/tools/r8/ClassConflictResolver.java
new file mode 100644
index 0000000..8136f17
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ClassConflictResolver.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2022, 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 com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.ClassReference;
+import java.util.Collection;
+
+@Keep
+public interface ClassConflictResolver {
+
+  /**
+   * Callback called in case the compiler is provided with duplicate class definitions.
+   *
+   * <p>The callback may be called multiple times for the same type with different origins, or it
+   * may be called once with all origins. Assuming the client has provided unique origins for the
+   * various inputs, the number of origins in any call will be at least two.
+   *
+   * <p>Note that all the duplicates are in the program's compilation unit. In other words, none of
+   * them are classpath or library definitions.
+   *
+   * @param reference The type reference of the duplicated class.
+   * @param origins The multiple origins of the class.
+   * @param handler Diagnostics handler for reporting.
+   * @return Returns the origin to use or null to fail compilation.
+   */
+  Origin resolveDuplicateClass(
+      ClassReference reference, Collection<Origin> origins, DiagnosticsHandler handler);
+}
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 33e984b..62d96d8 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -28,6 +28,7 @@
 import com.android.tools.r8.utils.InternalOptions.DesugarState;
 import com.android.tools.r8.utils.InternalOptions.HorizontalClassMergerOptions;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
+import com.android.tools.r8.utils.ProgramClassCollection;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -390,6 +391,7 @@
           getDumpInputFlags(),
           getMapIdProvider(),
           enableMissingLibraryApiModeling,
+          getClassConflictResolver(),
           factory);
     }
   }
@@ -476,6 +478,7 @@
       DumpInputFlags dumpInputFlags,
       MapIdProvider mapIdProvider,
       boolean enableMissingLibraryApiModeling,
+      ClassConflictResolver classConflictResolver,
       DexItemFactory factory) {
     super(
         inputApp,
@@ -493,7 +496,8 @@
         threadCount,
         dumpInputFlags,
         mapIdProvider,
-        null);
+        null,
+        classConflictResolver);
     this.intermediate = intermediate;
     this.globalSyntheticsConsumer = globalSyntheticsConsumer;
     this.desugarGraphConsumer = desugarGraphConsumer;
@@ -610,6 +614,10 @@
       horizontalClassMergerOptions.disable();
     }
 
+    internal.programClassConflictResolver =
+        ProgramClassCollection.wrappedConflictResolver(
+            getClassConflictResolver(), internal.reporter);
+
     internal.setDumpInputFlags(getDumpInputFlags(), skipDump);
     internal.dumpOptions = dumpOptions();
 
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index ee941db..fe430fc 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -23,6 +23,7 @@
 import com.android.tools.r8.utils.InternalOptions.DesugarState;
 import com.android.tools.r8.utils.InternalOptions.HorizontalClassMergerOptions;
 import com.android.tools.r8.utils.Pair;
+import com.android.tools.r8.utils.ProgramClassCollection;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -102,6 +103,7 @@
       int threadCount,
       DumpInputFlags dumpInputFlags,
       MapIdProvider mapIdProvider,
+      ClassConflictResolver classConflictResolver,
       DexItemFactory factory) {
     super(
         inputApp,
@@ -119,7 +121,8 @@
         threadCount,
         dumpInputFlags,
         mapIdProvider,
-        null);
+        null,
+        classConflictResolver);
     this.d8Command = d8Command;
     this.r8Command = r8Command;
     this.desugaredLibrarySpecification = desugaredLibrarySpecification;
@@ -209,6 +212,10 @@
                 .build(),
             getAssertionsConfiguration());
 
+    internal.programClassConflictResolver =
+        ProgramClassCollection.wrappedConflictResolver(
+            getClassConflictResolver(), internal.reporter);
+
     if (!DETERMINISTIC_DEBUGGING) {
       assert internal.threadCount == ThreadUtils.NOT_SPECIFIED;
       internal.threadCount = getThreadCount();
@@ -421,6 +428,7 @@
           getThreadCount(),
           getDumpInputFlags(),
           getMapIdProvider(),
+          getClassConflictResolver(),
           factory);
     }
   }
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index b834389..85a6a63 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -37,6 +37,7 @@
 import com.android.tools.r8.utils.InternalOptions.DesugarState;
 import com.android.tools.r8.utils.InternalOptions.HorizontalClassMergerOptions;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
+import com.android.tools.r8.utils.ProgramClassCollection;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -634,7 +635,8 @@
               getDumpInputFlags(),
               getMapIdProvider(),
               getSourceFileProvider(),
-              enableMissingLibraryApiModeling);
+              enableMissingLibraryApiModeling,
+              getClassConflictResolver());
 
       if (inputDependencyGraphConsumer != null) {
         inputDependencyGraphConsumer.finished();
@@ -802,7 +804,8 @@
       DumpInputFlags dumpInputFlags,
       MapIdProvider mapIdProvider,
       SourceFileProvider sourceFileProvider,
-      boolean enableMissingLibraryApiModeling) {
+      boolean enableMissingLibraryApiModeling,
+      ClassConflictResolver classConflictResolver) {
     super(
         inputApp,
         mode,
@@ -819,7 +822,8 @@
         threadCount,
         dumpInputFlags,
         mapIdProvider,
-        sourceFileProvider);
+        sourceFileProvider,
+        classConflictResolver);
     assert proguardConfiguration != null;
     assert mainDexKeepRules != null;
     this.mainDexKeepRules = mainDexKeepRules;
@@ -1014,6 +1018,10 @@
         SourceFileRewriter.computeSourceFileProvider(
             getSourceFileProvider(), proguardConfiguration, internal);
 
+    internal.programClassConflictResolver =
+        ProgramClassCollection.wrappedConflictResolver(
+            getClassConflictResolver(), internal.reporter);
+
     if (!DETERMINISTIC_DEBUGGING) {
       assert internal.threadCount == ThreadUtils.NOT_SPECIFIED;
       internal.threadCount = getThreadCount();
diff --git a/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java b/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java
index a5bbfcb..99b79e9 100644
--- a/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java
+++ b/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java
@@ -3,13 +3,16 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.utils;
 
+import com.android.tools.r8.ClassConflictResolver;
 import com.android.tools.r8.dex.ApplicationReader.ProgramClassConflictResolver;
 import com.android.tools.r8.errors.DuplicateTypesDiagnostic;
 import com.android.tools.r8.graph.ClassKind;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.Reference;
 import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
@@ -60,10 +63,28 @@
   public static ProgramClassConflictResolver defaultConflictResolver(Reporter reporter) {
     // The default conflict resolver only merges synthetic classes generated by D8 correctly.
     // All other conflicts are reported as a fatal error.
-    return (DexProgramClass a, DexProgramClass b) -> {
-      assert a.type == b.type;
-      if (a.accessFlags.isSynthetic() && b.accessFlags.isSynthetic()) {
-        return mergeClasses(reporter, a, b);
+    return wrappedConflictResolver(null, reporter);
+  }
+
+  public static ProgramClassConflictResolver wrappedConflictResolver(
+      ClassConflictResolver clientResolver, Reporter reporter) {
+    return (a, b) -> {
+      DexProgramClass clazz = mergeClasses(a, b);
+      if (clazz != null) {
+        return clazz;
+      }
+      if (clientResolver != null) {
+        List<Origin> origins = new ArrayList<>();
+        origins.add(a.getOrigin());
+        origins.add(b.getOrigin());
+        Origin origin =
+            clientResolver.resolveDuplicateClass(a.getClassReference(), origins, reporter);
+        if (origin == a.getOrigin()) {
+          return a;
+        }
+        if (origin == b.getOrigin()) {
+          return b;
+        }
       }
       throw reportDuplicateTypes(reporter, a, b);
     };
@@ -77,13 +98,22 @@
             ImmutableList.of(a.getOrigin(), b.getOrigin())));
   }
 
-  private static DexProgramClass mergeClasses(
-      Reporter reporter, DexProgramClass a, DexProgramClass b) {
+  private static DexProgramClass mergeClasses(DexProgramClass a, DexProgramClass b) {
+    assert a.type == b.type;
+    boolean syntheticA = a.accessFlags.isSynthetic();
+    boolean syntheticB = b.accessFlags.isSynthetic();
+    if (syntheticA && syntheticB) {
+      return mergeIfLegacySynthetics(a, b);
+    }
+    return null;
+  }
+
+  private static DexProgramClass mergeIfLegacySynthetics(DexProgramClass a, DexProgramClass b) {
     if (a.type.isLegacySynthesizedTypeAllowedDuplication()) {
       assert assertEqualClasses(a, b);
       return a;
     }
-    throw reportDuplicateTypes(reporter, a, b);
+    return null;
   }
 
   private static boolean assertEqualClasses(DexProgramClass a, DexProgramClass b) {
diff --git a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
index 905947d..a27cd51 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
@@ -9,6 +9,7 @@
 
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.compilerapi.assertionconfiguration.AssertionConfigurationTest;
+import com.android.tools.r8.compilerapi.classconflictresolver.ClassConflictResolverTest;
 import com.android.tools.r8.compilerapi.desugardependencies.DesugarDependenciesTest;
 import com.android.tools.r8.compilerapi.globalsynthetics.GlobalSyntheticsTest;
 import com.android.tools.r8.compilerapi.inputdependencies.InputDependenciesTest;
@@ -42,7 +43,9 @@
 
   private static final List<Class<? extends CompilerApiTest>> CLASSES_PENDING_BINARY_COMPATIBILITY =
       ImmutableList.of(
-          GlobalSyntheticsTest.ApiTest.class, EnableMissingLibraryApiModelingTest.ApiTest.class);
+          GlobalSyntheticsTest.ApiTest.class,
+          EnableMissingLibraryApiModelingTest.ApiTest.class,
+          ClassConflictResolverTest.ApiTest.class);
 
   private final TemporaryFolder temp;
 
diff --git a/src/test/java/com/android/tools/r8/compilerapi/classconflictresolver/ClassConflictResolverTest.java b/src/test/java/com/android/tools/r8/compilerapi/classconflictresolver/ClassConflictResolverTest.java
new file mode 100644
index 0000000..d328392
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/compilerapi/classconflictresolver/ClassConflictResolverTest.java
@@ -0,0 +1,116 @@
+// Copyright (c) 2022, 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.compilerapi.classconflictresolver;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ClassConflictResolver;
+import com.android.tools.r8.D8;
+import com.android.tools.r8.D8Command;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.R8;
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.compilerapi.CompilerApiTest;
+import com.android.tools.r8.compilerapi.CompilerApiTestRunner;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
+import com.android.tools.r8.utils.BooleanBox;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Paths;
+import org.junit.Test;
+
+public class ClassConflictResolverTest extends CompilerApiTestRunner {
+
+  public ClassConflictResolverTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Override
+  public Class<? extends CompilerApiTest> binaryTestClass() {
+    return ApiTest.class;
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    Origin originA = new PathOrigin(Paths.get("SourceA"));
+    Origin originB = new PathOrigin(Paths.get("SourceB"));
+    BooleanBox called = new BooleanBox(false);
+    new ApiTest(ApiTest.PARAMETERS)
+        .runD8(
+            originA,
+            originB,
+            (reference, origins, handler) -> {
+              called.set(true);
+              assertEquals(ImmutableSet.of(originA, originB), ImmutableSet.copyOf(origins));
+              return originA;
+            });
+    assertTrue(called.get());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Origin originA = new PathOrigin(Paths.get("SourceA"));
+    Origin originB = new PathOrigin(Paths.get("SourceB"));
+    BooleanBox called = new BooleanBox(false);
+    new ApiTest(ApiTest.PARAMETERS)
+        .runR8(
+            originA,
+            originB,
+            (reference, origins, handler) -> {
+              called.set(true);
+              assertEquals(ImmutableSet.of(originA, originB), ImmutableSet.copyOf(origins));
+              return originA;
+            });
+    assertTrue(called.get());
+  }
+
+  public static class ApiTest extends CompilerApiTest {
+
+    public ApiTest(Object parameters) {
+      super(parameters);
+    }
+
+    public void runD8(Origin originA, Origin originB, ClassConflictResolver resolver)
+        throws Exception {
+      D8.run(
+          D8Command.builder()
+              .addClassProgramData(getBytesForClass(getMockClass()), originA)
+              .addClassProgramData(getBytesForClass(getMockClass()), originB)
+              .addLibraryFiles(getJava8RuntimeJar())
+              .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+              .setClassConflictResolver(resolver)
+              .build());
+    }
+
+    public void runR8(Origin originA, Origin originB, ClassConflictResolver resolver)
+        throws Exception {
+      R8.run(
+          R8Command.builder()
+              .addClassProgramData(getBytesForClass(getMockClass()), originA)
+              .addClassProgramData(getBytesForClass(getMockClass()), originB)
+              .addLibraryFiles(getJava8RuntimeJar())
+              .setDisableTreeShaking(true)
+              .setDisableMinification(true)
+              .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+              .setClassConflictResolver(resolver)
+              .build());
+    }
+
+    @Test
+    public void testD8() throws Exception {
+      Origin originA = new PathOrigin(Paths.get("SourceA"));
+      Origin originB = new PathOrigin(Paths.get("SourceB"));
+      runD8(originA, originB, (reference, origins, handler) -> originA);
+    }
+
+    @Test
+    public void testR8() throws Exception {
+      Origin originA = new PathOrigin(Paths.get("SourceA"));
+      Origin originB = new PathOrigin(Paths.get("SourceB"));
+      runR8(originA, originB, (reference, origins, handler) -> originA);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java b/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
index 90771b4..a52c762 100644
--- a/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
+++ b/src/test/java/com/android/tools/r8/invalid/DuplicateDefinitionsTest.java
@@ -4,25 +4,39 @@
 
 package com.android.tools.r8.invalid;
 
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.jasmin.JasminTestBase;
-import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.nio.charset.Charset;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
+@RunWith(Parameterized.class)
 public class DuplicateDefinitionsTest extends JasminTestBase {
 
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultDexRuntime().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  private final TestParameters parameters;
+
+  public DuplicateDefinitionsTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
   @Test
   public void testDuplicateMethods() throws Exception {
     JasminBuilder jasminBuilder = new JasminBuilder();
@@ -32,38 +46,37 @@
     classBuilder.addVirtualMethod("method", "V", ".limit locals 1", ".limit stack 0", "return");
     classBuilder.addVirtualMethod("method", "V", ".limit locals 1", ".limit stack 0", "return");
 
-    // Run D8 and intercept warnings.
-    PrintStream stderr = System.err;
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    System.setErr(new PrintStream(baos));
+    testForD8(parameters.getBackend())
+        .addProgramClassFileData(jasminBuilder.buildClasses())
+        .setMinApi(parameters.getApiLevel())
+        .compileWithExpectedDiagnostics(
+            diagnostics ->
+                diagnostics
+                    .assertOnlyWarnings()
+                    .assertWarningsMatch(
+                        diagnosticMessage(
+                            containsString(
+                                "Ignoring an implementation of the method `void"
+                                    + " C.main(java.lang.String[])` because it has multiple"
+                                    + " definitions")),
+                        diagnosticMessage(
+                            containsString(
+                                "Ignoring an implementation of the method `void C.method()` because"
+                                    + " it has multiple definitions"))))
+        .inspect(
+            inspector -> {
+              ClassSubject clazz = inspector.clazz("C");
+              assertThat(clazz, isPresent());
 
-    AndroidApp app = compileWithD8(jasminBuilder.build());
+              // There are two direct methods, but only because one is <init>.
+              assertEquals(
+                  2, clazz.getDexProgramClass().getMethodCollection().numberOfDirectMethods());
+              assertThat(clazz.method("void", "<init>", ImmutableList.of()), isPresent());
 
-    String output = new String(baos.toByteArray(), Charset.defaultCharset());
-    System.setOut(stderr);
-
-    // Check that warnings were emitted.
-    assertThat(
-        output,
-        containsString(
-            "Ignoring an implementation of the method `void C.main(java.lang.String[])` because "
-                + "it has multiple definitions"));
-    assertThat(
-        output,
-        containsString(
-            "Ignoring an implementation of the method `void C.method()` because "
-                + "it has multiple definitions"));
-
-    CodeInspector inspector = new CodeInspector(app);
-    ClassSubject clazz = inspector.clazz("C");
-    assertThat(clazz, isPresent());
-
-    // There are two direct methods, but only because one is <init>.
-    assertEquals(2, clazz.getDexProgramClass().getMethodCollection().numberOfDirectMethods());
-    assertThat(clazz.method("void", "<init>", ImmutableList.of()), isPresent());
-
-    // There is only one virtual method.
-    assertEquals(1, clazz.getDexProgramClass().getMethodCollection().numberOfVirtualMethods());
+              // There is only one virtual method.
+              assertEquals(
+                  1, clazz.getDexProgramClass().getMethodCollection().numberOfVirtualMethods());
+            });
   }
 
   @Test
@@ -75,26 +88,26 @@
     classBuilder.addStaticField("staticFld", "LC;", null);
     classBuilder.addStaticField("staticFld", "LC;", null);
 
-    // Run D8 and intercept warnings.
-    PrintStream stderr = System.err;
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    System.setErr(new PrintStream(baos));
+    testForD8(parameters.getBackend())
+        .addProgramClassFileData(jasminBuilder.buildClasses())
+        .setMinApi(parameters.getApiLevel())
+        .compileWithExpectedDiagnostics(
+            diagnostics ->
+                diagnostics
+                    .assertOnlyWarnings()
+                    .assertWarningsMatch(
+                        diagnosticMessage(
+                            containsString("Field `C C.fld` has multiple definitions")),
+                        diagnosticMessage(
+                            containsString("Field `C C.staticFld` has multiple definitions"))))
+        .inspect(
+            inspector -> {
+              ClassSubject clazz = inspector.clazz("C");
+              assertThat(clazz, isPresent());
 
-    AndroidApp app = compileWithD8(jasminBuilder.build());
-
-    String output = new String(baos.toByteArray(), Charset.defaultCharset());
-    System.setOut(stderr);
-
-    // Check that warnings were emitted.
-    assertThat(output, containsString("Field `C C.fld` has multiple definitions"));
-    assertThat(output, containsString("Field `C C.staticFld` has multiple definitions"));
-
-    CodeInspector inspector = new CodeInspector(app);
-    ClassSubject clazz = inspector.clazz("C");
-    assertThat(clazz, isPresent());
-
-    // Redundant fields have been removed.
-    assertEquals(1, clazz.getDexProgramClass().instanceFields().size());
-    assertEquals(1, clazz.getDexProgramClass().staticFields().size());
+              // Redundant fields have been removed.
+              assertEquals(1, clazz.getDexProgramClass().instanceFields().size());
+              assertEquals(1, clazz.getDexProgramClass().staticFields().size());
+            });
   }
 }
diff --git a/src/test/java/com/android/tools/r8/invalid/DuplicateProgramTypesTest.java b/src/test/java/com/android/tools/r8/invalid/DuplicateProgramTypesTest.java
index e8c8d39..1efe38f 100644
--- a/src/test/java/com/android/tools/r8/invalid/DuplicateProgramTypesTest.java
+++ b/src/test/java/com/android/tools/r8/invalid/DuplicateProgramTypesTest.java
@@ -10,10 +10,12 @@
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
 
+import com.android.tools.r8.BaseCompilerCommand;
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
@@ -21,6 +23,8 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.SetUtils;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -32,7 +36,7 @@
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withNoneRuntime().build();
+    return getTestParameters().withDefaultDexRuntime().withApiLevel(AndroidApiLevel.B).build();
   }
 
   public DuplicateProgramTypesTest(TestParameters parameters) {
@@ -55,39 +59,113 @@
         }
       };
 
+  private void addDuplicateDefinitions(BaseCompilerCommand.Builder<?, ?> builder) throws Exception {
+    byte[] bytes = ToolHelper.getClassAsBytes(TestClass.class);
+    builder.addClassProgramData(bytes, originA);
+    builder.addClassProgramData(bytes, originB);
+  }
+
+  private void addResolvingHandler(BaseCompilerCommand.Builder<?, ?> builder) throws Exception {
+    builder.setClassConflictResolver(
+        (reference, origins, handler) -> {
+          assertEquals(
+              SetUtils.newIdentityHashSet(originA, originB), SetUtils.newIdentityHashSet(origins));
+          return originA;
+        });
+  }
+
+  private void addNonResolvingHandler(BaseCompilerCommand.Builder<?, ?> builder) throws Exception {
+    builder.setClassConflictResolver(
+        (reference, origins, handler) -> {
+          assertEquals(
+              SetUtils.newIdentityHashSet(originA, originB), SetUtils.newIdentityHashSet(origins));
+          return null;
+        });
+  }
+
+  private void checkErrorDiagnostic(TestDiagnosticMessages diagnostics) {
+    diagnostics.assertOnlyErrors();
+    diagnostics.assertErrorsCount(1);
+    DuplicateTypesDiagnostic diagnostic = (DuplicateTypesDiagnostic) diagnostics.getErrors().get(0);
+    assertEquals(Position.UNKNOWN, diagnostic.getPosition());
+    assertThat(diagnostic.getType(), equalTo(Reference.classFromClass(TestClass.class)));
+    assertThat(diagnostic.getOrigin(), anyOf(equalTo(originA), equalTo(originB)));
+    assertThat(diagnostic.getOrigins(), hasItems(originA, originB));
+    assertThat(
+        diagnostic.getDiagnosticMessage(),
+        allOf(
+            containsString("defined multiple"),
+            containsString("SourceA"),
+            containsString("SourceB")));
+  }
+
   @Test
-  public void test() throws Exception {
-    try {
-      byte[] bytes = ToolHelper.getClassAsBytes(TestClass.class);
-      testForD8()
-          .setMinApi(parameters.getRuntime())
-          .apply(
-              b -> {
-                b.getBuilder().addClassProgramData(bytes, originA);
-                b.getBuilder().addClassProgramData(bytes, originB);
-              })
-          .compileWithExpectedDiagnostics(
-              diagnostics -> {
-                diagnostics.assertOnlyErrors();
-                diagnostics.assertErrorsCount(1);
-                DuplicateTypesDiagnostic diagnostic =
-                    (DuplicateTypesDiagnostic) diagnostics.getErrors().get(0);
-                assertEquals(Position.UNKNOWN, diagnostic.getPosition());
-                assertThat(
-                    diagnostic.getType(), equalTo(Reference.classFromClass(TestClass.class)));
-                assertThat(diagnostic.getOrigin(), anyOf(equalTo(originA), equalTo(originB)));
-                assertThat(diagnostic.getOrigins(), hasItems(originA, originB));
-                assertThat(
-                    diagnostic.getDiagnosticMessage(),
-                    allOf(
-                        containsString("defined multiple"),
-                        containsString("SourceA"),
-                        containsString("SourceB")));
-              });
-    } catch (CompilationFailedException e) {
-      return; // Success.
-    }
-    fail("Expected test to fail with CompilationFailedException");
+  public void testDefaultError() throws Exception {
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForD8(parameters.getBackend())
+                .setMinApi(parameters.getApiLevel())
+                .apply(b -> addDuplicateDefinitions(b.getBuilder()))
+                .compileWithExpectedDiagnostics(this::checkErrorDiagnostic));
+  }
+
+  @Test
+  public void testResolvedConflictD8() throws Exception {
+    testForD8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .apply(
+            b -> {
+              addDuplicateDefinitions(b.getBuilder());
+              addResolvingHandler(b.getBuilder());
+            })
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello, world");
+  }
+
+  @Test
+  public void testResolvedConflictR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(TestClass.class)
+        .apply(
+            b -> {
+              addDuplicateDefinitions(b.getBuilder());
+              addResolvingHandler(b.getBuilder());
+            })
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello, world");
+  }
+
+  @Test
+  public void testNonResolvedConflictD8() throws Exception {
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForD8(parameters.getBackend())
+                .setMinApi(parameters.getApiLevel())
+                .apply(
+                    b -> {
+                      addDuplicateDefinitions(b.getBuilder());
+                      addNonResolvingHandler(b.getBuilder());
+                    })
+                .compileWithExpectedDiagnostics(this::checkErrorDiagnostic));
+  }
+
+  @Test
+  public void testNonResolvedConflictR8() throws Exception {
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForR8(parameters.getBackend())
+                .setMinApi(parameters.getApiLevel())
+                .addKeepMainRule(TestClass.class)
+                .apply(
+                    b -> {
+                      addDuplicateDefinitions(b.getBuilder());
+                      addNonResolvingHandler(b.getBuilder());
+                    })
+                .compileWithExpectedDiagnostics(this::checkErrorDiagnostic));
   }
 
   static class TestClass {