diff --git a/infra/config/global/cr-buildbucket.cfg b/infra/config/global/cr-buildbucket.cfg
index 2b6eb5f..ee1883c 100644
--- a/infra/config/global/cr-buildbucket.cfg
+++ b/infra/config/global/cr-buildbucket.cfg
@@ -149,6 +149,33 @@
       }
     }
     builders {
+      name: "linux-jdk8"
+      mixins: "linux"
+      mixins: "normal"
+      priority: 26
+      recipe {
+        properties_j: "test_options:[\"--runtimes=jdk8\", \"--no_internal\", \"--one_line_per_test\", \"--archive_failures\"]"
+      }
+    }
+    builders {
+      name: "linux-jdk9"
+      mixins: "linux"
+      mixins: "normal"
+      priority: 26
+      recipe {
+        properties_j: "test_options:[\"--runtimes=jdk9\", \"--no_internal\", \"--one_line_per_test\", \"--archive_failures\"]"
+      }
+    }
+    builders {
+      name: "linux-jdk8_9"
+      mixins: "linux"
+      mixins: "normal"
+      priority: 26
+      recipe {
+        properties_j: "test_options:[\"--runtimes=jdk8:jdk9\", \"--no_internal\", \"--one_line_per_test\", \"--archive_failures\"]"
+      }
+    }
+    builders {
       name: "linux_horizontal"
       mixins: "linux"
       mixins: "normal"
diff --git a/infra/config/global/luci-milo.cfg b/infra/config/global/luci-milo.cfg
index 90e3efc..bec8477 100644
--- a/infra/config/global/luci-milo.cfg
+++ b/infra/config/global/luci-milo.cfg
@@ -16,6 +16,21 @@
     short_name: "linux"
   }
   builders {
+    name: "buildbucket/luci.r8.ci/linux-jdk8"
+    category: "R8"
+    short_name: "jdk8"
+  }
+  builders {
+    name: "buildbucket/luci.r8.ci/linux-jdk9"
+    category: "R8"
+    short_name: "jdk9"
+  }
+  builders {
+    name: "buildbucket/luci.r8.ci/linux-jdk8_9"
+    category: "R8"
+    short_name: "jdk8_9"
+  }
+  builders {
     name: "buildbucket/luci.r8.ci/linux_horizontal"
     category: "R8"
     short_name: "horizontal"
diff --git a/infra/config/global/luci-notify.cfg b/infra/config/global/luci-notify.cfg
index e417700..4ed7592 100644
--- a/infra/config/global/luci-notify.cfg
+++ b/infra/config/global/luci-notify.cfg
@@ -29,6 +29,21 @@
     repository: "https://r8.googlesource.com/r8"
   }
   builders {
+    name: "linux-jdk8"
+    bucket: "ci"
+    repository: "https://r8.googlesource.com/r8"
+  }
+  builders {
+    name: "linux-jdk9"
+    bucket: "ci"
+    repository: "https://r8.googlesource.com/r8"
+  }
+  builders {
+    name: "linux-jdk8_9"
+    bucket: "ci"
+    repository: "https://r8.googlesource.com/r8"
+  }
+  builders {
     name: "linux_horizontal"
     bucket: "ci"
     repository: "https://r8.googlesource.com/r8"
diff --git a/infra/config/global/luci-scheduler.cfg b/infra/config/global/luci-scheduler.cfg
index fcf4105..634885f 100644
--- a/infra/config/global/luci-scheduler.cfg
+++ b/infra/config/global/luci-scheduler.cfg
@@ -27,6 +27,9 @@
   }
   triggers: "archive"
   triggers: "linux"
+  triggers: "linux-jdk8"
+  triggers: "linux-jdk9"
+  triggers: "linux-jdk8_9"
   triggers: "linux_horizontal"
   triggers: "linux-android-4.0.4"
   triggers: "linux-android-4.4.4"
@@ -138,6 +141,49 @@
 }
 
 job {
+  id: "linux-jdk8"
+  acl_sets: "default"
+  triggering_policy: {
+    kind: GREEDY_BATCHING
+    max_concurrent_invocations: 2
+  }
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "luci.r8.ci"
+    builder: "linux-jdk8"
+  }
+}
+
+job {
+  id: "linux-jdk9"
+  acl_sets: "default"
+  triggering_policy: {
+    kind: GREEDY_BATCHING
+    max_concurrent_invocations: 2
+  }
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "luci.r8.ci"
+    builder: "linux-jdk9"
+  }
+}
+
+job {
+  id: "linux-jdk8_9"
+  acl_sets: "default"
+  triggering_policy: {
+    kind: GREEDY_BATCHING
+    max_concurrent_invocations: 2
+  }
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "luci.r8.ci"
+    builder: "linux-jdk8_9"
+  }
+}
+
+
+job {
   id: "linux_horizontal"
   acl_sets: "default"
   triggering_policy: {
diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java b/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
index 18b86c7..45878c9 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
@@ -19,6 +19,7 @@
 
   protected static final String MIN_API_FLAG = "--min-api";
   protected static final String THREAD_COUNT_FLAG = "--thread-count";
+  protected static final String MAP_DIAGNOSTICS = "--map-diagnostics";
 
   static final Iterable<String> ASSERTIONS_USAGE_MESSAGE =
       Arrays.asList(
@@ -43,6 +44,17 @@
           "                          # the number will be based on heuristics taking the number",
           "                          # of cores into account.");
 
+  static final Iterable<String> MAP_DIAGNOSTICS_USAGE_MESSAGE =
+      Arrays.asList(
+          "  " + MAP_DIAGNOSTICS + "[:<type>] <from-level> <to-level>",
+          "                          # Map diagnostics of <type> (default any) reported as",
+          "                          # <from-level> to <to-level> where <from-level> and",
+          "                          # <to-level> are one of 'info', 'warning', or 'error' and the",
+          "                          # optional <type> is either the simple or fully qualified",
+          "                          # Java type name of a diagnostic. If <type> is unspecified,",
+          "                          # all diagnostics at <from-level> will be mapped.",
+          "                          # Note that fatal compiler errors cannot be mapped.");
+
   public static void parsePositiveIntArgument(
       Consumer<Diagnostic> errorConsumer,
       String flag,
@@ -140,6 +152,52 @@
     }
   }
 
+  private DiagnosticsLevel tryParseLevel(B builder, String arg, Origin origin) {
+    if (arg.equals("error")) {
+      return DiagnosticsLevel.ERROR;
+    }
+    if (arg.equals("warning")) {
+      return DiagnosticsLevel.WARNING;
+    }
+    if (arg.equals("info")) {
+      return DiagnosticsLevel.INFO;
+    }
+    builder.error(
+        new StringDiagnostic(
+            "Invalid diagnostics level '"
+                + arg
+                + "'. Valid levels are 'error', 'warning' and 'info'.",
+            origin));
+
+    return null;
+  }
+
+  int tryParseMapDiagnostics(B builder, String arg, String[] args, int argsIndex, Origin origin) {
+    if (!arg.startsWith(MAP_DIAGNOSTICS)) {
+      return -1;
+    }
+    if (args.length <= argsIndex + 2) {
+      builder.error(new StringDiagnostic("Missing argument(s) for " + arg + ".", origin));
+      return args.length - argsIndex;
+    }
+    String remaining = arg.substring(MAP_DIAGNOSTICS.length());
+    String diagnosticsClassName = "";
+    if (remaining.length() > 0) {
+      if (remaining.length() == 1 || remaining.charAt(0) != ':') {
+        builder.error(
+            new StringDiagnostic("Invalid diagnostics type specification " + arg + ".", origin));
+        return 0;
+      }
+      diagnosticsClassName = remaining.substring(1);
+    }
+    DiagnosticsLevel from = tryParseLevel(builder, args[argsIndex + 1], origin);
+    DiagnosticsLevel to = tryParseLevel(builder, args[argsIndex + 2], origin);
+    if (from != null && to != null) {
+      builder.getReporter().addDiagnosticsLevelMapping(from, diagnosticsClassName, to);
+    }
+    return 2;
+  }
+
   /**
    * This method must match the lookup in
    * {@link com.android.tools.r8.JdkClassFileProvider#fromJdkHome}.
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 0a38fb5..8e56a8e 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -249,7 +249,10 @@
       Marker marker = options.getMarker(Tool.D8);
       Set<Marker> markers = new HashSet<>(appView.dexItemFactory().extractMarkers());
       // TODO(b/166617364): Don't add an additional marker when desugaring is turned off.
-      if (hasClassResources && (options.desugarState != DesugarState.OFF || markers.isEmpty())) {
+      if (hasClassResources
+          && (options.desugarState != DesugarState.OFF
+              || markers.isEmpty()
+              || (markers.size() == 1 && markers.iterator().next().isL8()))) {
         markers.add(marker);
       }
       Marker.checkCompatibleDesugaredLibrary(markers, options.reporter);
diff --git a/src/main/java/com/android/tools/r8/D8CommandParser.java b/src/main/java/com/android/tools/r8/D8CommandParser.java
index 2ed9890..d705c8e 100644
--- a/src/main/java/com/android/tools/r8/D8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/D8CommandParser.java
@@ -144,6 +144,7 @@
                   "                          # Output resulting main dex list in <file>."),
               ASSERTIONS_USAGE_MESSAGE,
               THREAD_COUNT_USAGE_MESSAGE,
+              MAP_DIAGNOSTICS_USAGE_MESSAGE,
               Arrays.asList(
                   "  --version               # Print the version of d8.",
                   "  --help                  # Print this message.")));
@@ -276,10 +277,15 @@
       } else if (arg.equals("--desugared-lib")) {
         builder.addDesugaredLibraryConfiguration(StringResource.fromFile(Paths.get(nextArg)));
       } else if (arg.startsWith("--")) {
-        if (!tryParseAssertionArgument(builder, arg, origin)) {
-          builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
+        if (tryParseAssertionArgument(builder, arg, origin)) {
           continue;
         }
+        int argsConsumed = tryParseMapDiagnostics(builder, arg, expandedArgs, i, origin);
+        if (argsConsumed >= 0) {
+          i += argsConsumed;
+          continue;
+        }
+        builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
       } else if (arg.startsWith("@")) {
         builder.error(new StringDiagnostic("Recursive @argfiles are not supported: ", origin));
       } else {
diff --git a/src/main/java/com/android/tools/r8/GenerateLintFiles.java b/src/main/java/com/android/tools/r8/GenerateLintFiles.java
index f3acbec..b77db45 100644
--- a/src/main/java/com/android/tools/r8/GenerateLintFiles.java
+++ b/src/main/java/com/android/tools/r8/GenerateLintFiles.java
@@ -356,7 +356,7 @@
 
   private void run() throws Exception {
     // Run over all the API levels that the desugared library can be compiled with.
-    for (int apiLevel = AndroidApiLevel.Q.getLevel();
+    for (int apiLevel = AndroidApiLevel.LATEST.getLevel();
         apiLevel >= desugaredLibraryConfiguration.getRequiredCompilationApiLevel().getLevel();
         apiLevel--) {
       System.out.println("Generating lint files for compile API " + apiLevel);
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index 221df4c..1141688 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -316,6 +316,7 @@
         r8Builder.addProguardConfiguration(
             libraryConfiguration.getExtraKeepRules(), Origin.unknown());
         r8Builder.addProguardConfigurationFiles(proguardConfigFiles);
+        r8Builder.setDisableDesugaring(true);
         r8Command = r8Builder.makeCommand();
       } else if (!(getProgramConsumer() instanceof ClassFileConsumer)) {
         l8CfConsumer = new InMemoryJarContent();
@@ -333,6 +334,7 @@
             inputs.getLibraryResourceProviders()) {
           d8Builder.addLibraryResourceProvider(libraryResourceProvider);
         }
+        d8Builder.setDisableDesugaring(true);
         d8Command = d8Builder.makeCommand();
       } else {
         assert getProgramConsumer() instanceof ClassFileConsumer;
diff --git a/src/main/java/com/android/tools/r8/L8CommandParser.java b/src/main/java/com/android/tools/r8/L8CommandParser.java
index e816320..0a57389 100644
--- a/src/main/java/com/android/tools/r8/L8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/L8CommandParser.java
@@ -55,6 +55,7 @@
                       + " (json)."),
               ASSERTIONS_USAGE_MESSAGE,
               THREAD_COUNT_USAGE_MESSAGE,
+              MAP_DIAGNOSTICS_USAGE_MESSAGE,
               Arrays.asList(
                   "  --version               # Print the version of l8.",
                   "  --help                  # Print this message.")));
@@ -156,10 +157,15 @@
         parsePositiveIntArgument(
             builder::error, THREAD_COUNT_FLAG, nextArg, origin, builder::setThreadCount);
       } else if (arg.startsWith("--")) {
-        if (!tryParseAssertionArgument(builder, arg, origin)) {
-          builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
+        if (tryParseAssertionArgument(builder, arg, origin)) {
           continue;
         }
+        int argsConsumed = tryParseMapDiagnostics(builder, arg, expandedArgs, i, origin);
+        if (argsConsumed >= 0) {
+          i += argsConsumed;
+          continue;
+        }
+        builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
       } else {
         builder.addProgramFiles(Paths.get(arg));
       }
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 5e8e3a6..dad6c63 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -313,6 +313,7 @@
       }
       if (!options.desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()) {
         DesugaredLibraryRetargeter.checkForAssumedLibraryTypes(appView);
+        DesugaredLibraryRetargeter.amendLibraryWithRetargetedMembers(appView);
       }
       InterfaceMethodRewriter.checkForAssumedLibraryTypes(appView.appInfo(), options);
       BackportedMethodRewriter.registerAssumedLibraryTypes(options);
diff --git a/src/main/java/com/android/tools/r8/R8CommandParser.java b/src/main/java/com/android/tools/r8/R8CommandParser.java
index b796705..3cb01e1 100644
--- a/src/main/java/com/android/tools/r8/R8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/R8CommandParser.java
@@ -100,6 +100,7 @@
                   "                          # Output the full main-dex list in <file>."),
               ASSERTIONS_USAGE_MESSAGE,
               THREAD_COUNT_USAGE_MESSAGE,
+              MAP_DIAGNOSTICS_USAGE_MESSAGE,
               Arrays.asList(
                   "  --version               # Print the version of r8.",
                   "  --help                  # Print this message.")));
@@ -262,10 +263,15 @@
       } else if (arg.equals("--no-data-resources")) {
         state.includeDataResources = false;
       } else if (arg.startsWith("--")) {
-        if (!tryParseAssertionArgument(builder, arg, argsOrigin)) {
-          builder.error(new StringDiagnostic("Unknown option: " + arg, argsOrigin));
+        if (tryParseAssertionArgument(builder, arg, argsOrigin)) {
           continue;
         }
+        int argsConsumed = tryParseMapDiagnostics(builder, arg, expandedArgs, i, argsOrigin);
+        if (argsConsumed >= 0) {
+          i += argsConsumed;
+          continue;
+        }
+        builder.error(new StringDiagnostic("Unknown option: " + arg, argsOrigin));
       } else if (arg.startsWith("@")) {
         builder.error(new StringDiagnostic("Recursive @argfiles are not supported: ", argsOrigin));
       } else {
diff --git a/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java b/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
index e3584ec..b43a42c 100644
--- a/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
+++ b/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
@@ -115,7 +115,7 @@
       // When not coming from DEX input we require interfaces to be abstract - except for
       // package-info classes - as both old versions of javac and other tools can produce
       // package-info classes that are interfaces but not abstract.
-      if (version.isGreaterThanOrEqual(Constants.CORRESPONDING_CLASS_FILE_VERSION)
+      if (version.isGreaterThan(Constants.CORRESPONDING_CLASS_FILE_VERSION)
           && !isAbstract()
           && !isPackageInfo) {
         return false;
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index 9757af4..a0d4cbe 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -250,6 +250,11 @@
     return factory.isConstructor(this);
   }
 
+  public DexMethod withExtraArgumentPrepended(DexType type, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createMethod(
+        holder, dexItemFactory.prependTypeToProto(type, proto), name);
+  }
+
   public DexMethod withHolder(DexType holder, DexItemFactory dexItemFactory) {
     return dexItemFactory.createMethod(holder, proto, name);
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
index 3295733..54d6795 100644
--- a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
@@ -218,6 +218,12 @@
       return self();
     }
 
+    public Builder addLibraryClasses(Collection<DexLibraryClass> classes) {
+      libraryClasses =
+          ImmutableList.<DexLibraryClass>builder().addAll(libraryClasses).addAll(classes).build();
+      return self();
+    }
+
     @Override
     public DirectMappedDexApplication build() {
       // Rebuild the map. This will fail if keys are not unique.
diff --git a/src/main/java/com/android/tools/r8/graph/EnclosingMethodAttribute.java b/src/main/java/com/android/tools/r8/graph/EnclosingMethodAttribute.java
index 5457311..82f34d7 100644
--- a/src/main/java/com/android/tools/r8/graph/EnclosingMethodAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/EnclosingMethodAttribute.java
@@ -32,6 +32,10 @@
     this.enclosingMethod = enclosingMethod;
   }
 
+  public static EnclosingMethodAttribute none() {
+    return null;
+  }
+
   public void write(ClassWriter writer, NamingLens lens) {
     if (enclosingMethod != null) {
       writer.visitOuterClass(
diff --git a/src/main/java/com/android/tools/r8/graph/InnerClassAttribute.java b/src/main/java/com/android/tools/r8/graph/InnerClassAttribute.java
index f3195c9..d54bc7b 100644
--- a/src/main/java/com/android/tools/r8/graph/InnerClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/InnerClassAttribute.java
@@ -7,6 +7,8 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.InternalOptions;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Consumer;
 import org.objectweb.asm.ClassWriter;
 
@@ -39,6 +41,10 @@
     this.innerName = innerName;
   }
 
+  public static List<InnerClassAttribute> emptyList() {
+    return Collections.emptyList();
+  }
+
   public void forEachType(Consumer<DexType> consumer) {
     if (inner != null) {
       consumer.accept(inner);
diff --git a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
index 96fb82b..e007f4e 100644
--- a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
@@ -19,6 +19,10 @@
     return nestHost;
   }
 
+  public static NestHostClassAttribute none() {
+    return null;
+  }
+
   public void write(ClassWriter writer, NamingLens lens) {
     assert nestHost != null;
     writer.visitNestHost(lens.lookupInternalName(nestHost));
diff --git a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
index f88a39f..f9d1a35 100644
--- a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
@@ -5,6 +5,8 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.naming.NamingLens;
+import java.util.Collections;
+import java.util.List;
 import org.objectweb.asm.ClassWriter;
 
 public class NestMemberClassAttribute {
@@ -15,6 +17,10 @@
     this.nestMember = nestMember;
   }
 
+  public static List<NestMemberClassAttribute> emptyList() {
+    return Collections.emptyList();
+  }
+
   public DexType getNestMember() {
     return nestMember;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index c271af1..960dea0 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -48,7 +48,6 @@
 import com.android.tools.r8.ir.desugar.D8NestBasedAccessDesugaring;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter.Mode;
-import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor;
@@ -214,13 +213,18 @@
             .map(options.itemFactory::createString)
             .collect(Collectors.toList());
     if (options.isDesugaredLibraryCompilation()) {
-      // Specific L8 Settings.
-      // DesugaredLibraryRetargeter is needed for retarget core library members and backports.
-      // InterfaceMethodRewriter is needed for emulated interfaces.
-      // LambdaRewriter is needed because if it is missing there are invoke custom on
-      // default/static interface methods, and this is not supported by the compiler.
-      // DesugaredLibraryAPIConverter is here to duplicate APIs.
-      // The rest is nulled out. In addition the rewriting logic fails without lambda rewriting.
+      // Specific L8 Settings, performs all desugaring including L8 specific desugaring.
+      // The following desugaring are required for L8 specific desugaring:
+      // - DesugaredLibraryRetargeter for retarget core library members.
+      // - InterfaceMethodRewriter for emulated interfaces,
+      // - LambdaRewriter since InterfaceMethodDesugaring does not support invokeCustom rewriting,
+      // - DesugaredLibraryAPIConverter to duplicate APIs.
+      // The following desugaring are present so all desugaring is performed cf to cf in L8, and
+      // the second L8 phase can just run with Desugar turned off:
+      // - InterfaceMethodRewriter for non L8 specific interface method desugaring,
+      // - TwrCloseResourceRewriter,
+      // - NestBaseAccessDesugaring.
+      assert options.desugarState == DesugarState.ON;
       this.desugaredLibraryRetargeter =
           options.desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()
               ? null
@@ -232,11 +236,11 @@
       this.lambdaRewriter = new LambdaRewriter(appView);
       this.desugaredLibraryAPIConverter =
           new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS);
-      this.backportedMethodRewriter =
-          options.cfToCfDesugar || options.testing.forceLibBackportsInL8CfToCf
-              ? new BackportedMethodRewriter(appView)
-              : null;
-      this.twrCloseResourceRewriter = null;
+      this.backportedMethodRewriter = new BackportedMethodRewriter(appView);
+      this.twrCloseResourceRewriter =
+          enableTwrCloseResourceDesugaring() ? new TwrCloseResourceRewriter(appView, this) : null;
+      this.d8NestBasedAccessDesugaring =
+          options.shouldDesugarNests() ? new D8NestBasedAccessDesugaring(appView) : null;
       this.lambdaMerger = null;
       this.covariantReturnTypeAnnotationTransformer = null;
       this.dynamicTypeOptimization = null;
@@ -251,7 +255,6 @@
       this.identifierNameStringMarker = null;
       this.devirtualizer = null;
       this.typeChecker = null;
-      this.d8NestBasedAccessDesugaring = null;
       this.stringSwitchRemover = null;
       this.serviceLoaderRewriter = null;
       this.methodOptimizationInfoCollector = null;
@@ -552,13 +555,6 @@
       return true;
     }
     if (options.isDesugaredLibraryCompilation()) {
-      // TODO(b/169035524): Create method for evaluating if a code object needs rewriting for
-      // library desugaring.
-      return true;
-    }
-    if (options.desugaredLibraryConfiguration != DesugaredLibraryConfiguration.empty()) {
-      // TODO(b/169035524): Create method for evaluating if a code object needs rewriting for
-      // library desugaring.
       return true;
     }
 
@@ -569,14 +565,21 @@
       return true;
     }
 
-    NeedsIRDesugarUseRegistry useRegistry =
-        new NeedsIRDesugarUseRegistry(appView, backportedMethodRewriter);
-    method.registerCodeReferences(useRegistry);
-
-    if (useRegistry.needsDesugaring()) {
+    if (desugaredLibraryAPIConverter != null
+        && desugaredLibraryAPIConverter.shouldRegisterCallback(method)) {
       return true;
     }
-    return false;
+
+    NeedsIRDesugarUseRegistry useRegistry =
+        new NeedsIRDesugarUseRegistry(
+            appView,
+            backportedMethodRewriter,
+            desugaredLibraryRetargeter,
+            interfaceMethodRewriter,
+            desugaredLibraryAPIConverter);
+    method.registerCodeReferences(useRegistry);
+
+    return useRegistry.needsDesugaring();
   }
 
   private void checkPrefixMerging(ProgramMethod method) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index 0512e69..8e1ee32 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -89,6 +89,7 @@
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.optimize.enums.EnumUnboxer;
 import com.android.tools.r8.logging.Log;
+import com.android.tools.r8.optimize.MemberRebindingAnalysis;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -594,7 +595,7 @@
       if (definition != null) {
         DexClassAndField field = DexClassAndField.create(holder, definition);
         if (AccessControl.isMemberAccessible(field, holder, context, appView).isTrue()) {
-          return lookup.getReboundReference();
+          return MemberRebindingAnalysis.validMemberRebindingTargetFor(appView, field, reference);
         }
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
index 9d88a1f..f6ad5f3 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
@@ -11,6 +11,9 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
+import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
 import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
 
 class NeedsIRDesugarUseRegistry extends UseRegistry {
@@ -18,12 +21,22 @@
   private boolean needsDesugarging = false;
   private final AppView appView;
   private final BackportedMethodRewriter backportedMethodRewriter;
+  private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
+  private final InterfaceMethodRewriter interfaceMethodRewriter;
+  private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
 
   public NeedsIRDesugarUseRegistry(
-      AppView appView, BackportedMethodRewriter backportedMethodRewriter) {
+      AppView appView,
+      BackportedMethodRewriter backportedMethodRewriter,
+      DesugaredLibraryRetargeter desugaredLibraryRetargeter,
+      InterfaceMethodRewriter interfaceMethodRewriter,
+      DesugaredLibraryAPIConverter desugaredLibraryAPIConverter) {
     super(appView.dexItemFactory());
     this.appView = appView;
     this.backportedMethodRewriter = backportedMethodRewriter;
+    this.desugaredLibraryRetargeter = desugaredLibraryRetargeter;
+    this.interfaceMethodRewriter = interfaceMethodRewriter;
+    this.desugaredLibraryAPIConverter = desugaredLibraryAPIConverter;
   }
 
   public boolean needsDesugaring() {
@@ -31,31 +44,75 @@
   }
 
   @Override
-  public void registerInitClass(DexType type) {}
+  public void registerInitClass(DexType type) {
+    if (!needsDesugarging
+        && desugaredLibraryAPIConverter != null
+        && desugaredLibraryAPIConverter.canConvert(type)) {
+      needsDesugarging = true;
+    }
+  }
 
   @Override
   public void registerInvokeVirtual(DexMethod method) {
-    if (backportedMethodRewriter.needsDesugaring(method)) {
-      needsDesugarging = true;
-    }
+    registerBackportedMethodRewriting(method);
+    registerLibraryRetargeting(method, false);
+    registerInterfaceMethodRewriting(method);
+    registerDesugaredLibraryAPIConverter(method);
   }
 
   @Override
-  public void registerInvokeDirect(DexMethod method) {}
+  public void registerInvokeDirect(DexMethod method) {
+    registerLibraryRetargeting(method, false);
+    registerInterfaceMethodRewriting(method);
+    registerDesugaredLibraryAPIConverter(method);
+  }
+
+  private void registerBackportedMethodRewriting(DexMethod method) {
+    if (!needsDesugarging) {
+      needsDesugarging = backportedMethodRewriter.needsDesugaring(method);
+    }
+  }
+
+  private void registerInterfaceMethodRewriting(DexMethod method) {
+    if (!needsDesugarging) {
+      needsDesugarging =
+          interfaceMethodRewriter != null && interfaceMethodRewriter.needsRewriting(method);
+    }
+  }
+
+  private void registerDesugaredLibraryAPIConverter(DexMethod method) {
+    if (!needsDesugarging) {
+      needsDesugarging =
+          desugaredLibraryAPIConverter != null
+              && desugaredLibraryAPIConverter.shouldRewriteInvoke(method);
+    }
+  }
+
+  private void registerLibraryRetargeting(DexMethod method, boolean b) {
+    if (!needsDesugarging) {
+      needsDesugarging =
+          desugaredLibraryRetargeter != null
+              && desugaredLibraryRetargeter.getRetargetedMethod(method, b) != null;
+    }
+  }
 
   @Override
   public void registerInvokeStatic(DexMethod method) {
-    if (TwrCloseResourceRewriter.isSynthesizedCloseResourceMethod(method, appView)) {
-      needsDesugarging = true;
+    if (!needsDesugarging) {
+      needsDesugarging = TwrCloseResourceRewriter.isSynthesizedCloseResourceMethod(method, appView);
     }
-
-    if (backportedMethodRewriter.needsDesugaring(method)) {
-      needsDesugarging = true;
-    }
+    registerBackportedMethodRewriting(method);
+    registerLibraryRetargeting(method, false);
+    registerInterfaceMethodRewriting(method);
+    registerDesugaredLibraryAPIConverter(method);
   }
 
   @Override
-  public void registerInvokeInterface(DexMethod method) {}
+  public void registerInvokeInterface(DexMethod method) {
+    registerLibraryRetargeting(method, true);
+    registerInterfaceMethodRewriting(method);
+    registerDesugaredLibraryAPIConverter(method);
+  }
 
   @Override
   public void registerInvokeStatic(DexMethod method, boolean itf) {
@@ -72,7 +129,11 @@
   }
 
   @Override
-  public void registerInvokeSuper(DexMethod method) {}
+  public void registerInvokeSuper(DexMethod method) {
+    registerLibraryRetargeting(method, false);
+    registerInterfaceMethodRewriting(method);
+    registerDesugaredLibraryAPIConverter(method);
+  }
 
   @Override
   public void registerInstanceFieldRead(DexField field) {}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 04fb914..11e6e33 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -75,7 +75,7 @@
   }
 
   public boolean needsDesugaring(DexMethod method) {
-    return rewritableMethods.getProvider(method) != null;
+    return getMethodProviderOrNull(method) != null;
   }
 
   public static List<DexMethod> generateListOfBackportedMethods(
@@ -165,7 +165,30 @@
   private MethodProvider getMethodProviderOrNull(DexMethod method) {
     DexMethod original = appView.graphLens().getOriginalMethodSignature(method);
     assert original != null;
-    return rewritableMethods.getProvider(original);
+    MethodProvider provider = rewritableMethods.getProvider(original);
+    // TODO(b/150693139): Since the DesugarLibraryRetargeter is run during IR processing while the
+    // backported method rewriter is run in cf to cf, we need here to compute if the method is
+    // actually going to be retargeted through desugared library backports, and compute the
+    // corresponding backported method if so. This can be removed once the DesugarLibraryRetargeter
+    // has been moved as a cf to cf transformation.
+    if (provider == null
+        && appView.options().isDesugaredLibraryCompilation()
+        && appView
+            .options()
+            .desugaredLibraryConfiguration
+            .getBackportCoreLibraryMember()
+            .containsKey(method.holder)) {
+      DexType newHolder =
+          appView
+              .options()
+              .desugaredLibraryConfiguration
+              .getBackportCoreLibraryMember()
+              .get(method.holder);
+      DexMethod backportedMethod =
+          appView.dexItemFactory().createMethod(newHolder, method.proto, method.name);
+      provider = rewritableMethods.getProvider(backportedMethod);
+    }
+    return provider;
   }
 
   private static final class RewritableMethods {
@@ -175,15 +198,6 @@
 
     RewritableMethods(InternalOptions options, AppView<?> appView) {
 
-      if (options.testing.forceLibBackportsInL8CfToCf) {
-        DexItemFactory factory = options.itemFactory;
-        initializeJava9OptionalMethodProviders(factory);
-        initializeJava10OptionalMethodProviders(factory);
-        initializeJava11OptionalMethodProviders(factory);
-        initializeStreamMethodProviders(factory);
-        return;
-      }
-
       if (!options.shouldBackportMethods()) {
         return;
       }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java
index bd468b0..787915f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java
@@ -146,6 +146,9 @@
   public void desugarNestBasedAccess(
       DexApplication.Builder<?> builder, ExecutorService executorService, IRConverter converter)
       throws ExecutionException {
+    if (metNestHosts.isEmpty()) {
+      return;
+    }
     processNestsConcurrently(executorService);
     addDeferredBridges();
     synthesizeNestConstructor(builder);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
index 401297e..c337afe 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
@@ -146,7 +146,7 @@
     return true;
   }
 
-  private boolean shouldRewriteInvoke(DexMethod invokedMethod) {
+  public boolean shouldRewriteInvoke(DexMethod invokedMethod) {
     if (appView.rewritePrefix.hasRewrittenType(invokedMethod.holder, appView)
         || invokedMethod.holder.isArrayType()) {
       return false;
@@ -164,7 +164,7 @@
     }
   }
 
-  private boolean shouldRegisterCallback(ProgramMethod method) {
+  public boolean shouldRegisterCallback(ProgramMethod method) {
     // Any override of a library method can be called by the library.
     // We duplicate the method to have a vivified type version callable by the library and
     // a type version callable by the program. We need to add the vivified version to the rootset
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
index 68a2df3..904ca7e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
@@ -4,7 +4,9 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.ProgramResource.Kind;
 import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.graph.DexAnnotationSet;
@@ -22,10 +24,15 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.graph.EnclosingMethodAttribute;
 import com.android.tools.r8.graph.GenericSignature.ClassSignature;
 import com.android.tools.r8.graph.GenericSignature.ClassTypeSignature;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
+import com.android.tools.r8.graph.InnerClassAttribute;
 import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.graph.NestHostClassAttribute;
+import com.android.tools.r8.graph.NestMemberClassAttribute;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.ir.code.IRCode;
@@ -42,9 +49,12 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.function.Consumer;
@@ -84,6 +94,109 @@
     }
   }
 
+  public static void amendLibraryWithRetargetedMembers(AppView<AppInfoWithClassHierarchy> appView) {
+    Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
+        appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
+    Map<DexType, DexLibraryClass> synthesizedLibraryClasses =
+        synthesizeLibraryClassesForRetargetedMembers(appView, retargetCoreLibMember);
+    Map<DexLibraryClass, Set<DexEncodedMethod>> synthesizedLibraryMethods =
+        synthesizedMembersForRetargetClasses(
+            appView, retargetCoreLibMember, synthesizedLibraryClasses);
+    synthesizedLibraryMethods.forEach(DexLibraryClass::addDirectMethods);
+    DirectMappedDexApplication newApplication =
+        appView
+            .appInfo()
+            .app()
+            .asDirect()
+            .builder()
+            .addLibraryClasses(synthesizedLibraryClasses.values())
+            .build();
+    appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(app -> newApplication));
+  }
+
+  private static Map<DexType, DexLibraryClass> synthesizeLibraryClassesForRetargetedMembers(
+      AppView<AppInfoWithClassHierarchy> appView,
+      Map<DexString, Map<DexType, DexType>> retargetCoreLibMember) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    Map<DexType, DexLibraryClass> synthesizedLibraryClasses = new LinkedHashMap<>();
+    for (Map<DexType, DexType> oldToNewTypeMap : retargetCoreLibMember.values()) {
+      for (DexType newType : oldToNewTypeMap.values()) {
+        if (appView.definitionFor(newType) == null) {
+          synthesizedLibraryClasses.computeIfAbsent(
+              newType,
+              type ->
+                  // Synthesize a library class with the given name. Note that this is assuming that
+                  // the library class inherits directly from java.lang.Object, does not implement
+                  // any interfaces, etc.
+                  new DexLibraryClass(
+                      type,
+                      Kind.CF,
+                      new SynthesizedOrigin(
+                          "Desugared library retargeter", DesugaredLibraryRetargeter.class),
+                      ClassAccessFlags.fromCfAccessFlags(Constants.ACC_PUBLIC),
+                      dexItemFactory.objectType,
+                      DexTypeList.empty(),
+                      dexItemFactory.createString("DesugaredLibraryRetargeter"),
+                      NestHostClassAttribute.none(),
+                      NestMemberClassAttribute.emptyList(),
+                      EnclosingMethodAttribute.none(),
+                      InnerClassAttribute.emptyList(),
+                      ClassSignature.noSignature(),
+                      DexAnnotationSet.empty(),
+                      DexEncodedField.EMPTY_ARRAY,
+                      DexEncodedField.EMPTY_ARRAY,
+                      DexEncodedMethod.EMPTY_ARRAY,
+                      DexEncodedMethod.EMPTY_ARRAY,
+                      dexItemFactory.getSkipNameValidationForTesting()));
+        }
+      }
+    }
+    return synthesizedLibraryClasses;
+  }
+
+  private static Map<DexLibraryClass, Set<DexEncodedMethod>> synthesizedMembersForRetargetClasses(
+      AppView<AppInfoWithClassHierarchy> appView,
+      Map<DexString, Map<DexType, DexType>> retargetCoreLibMember,
+      Map<DexType, DexLibraryClass> synthesizedLibraryClasses) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    Map<DexLibraryClass, Set<DexEncodedMethod>> synthesizedMembers = new IdentityHashMap<>();
+    for (Entry<DexString, Map<DexType, DexType>> entry : retargetCoreLibMember.entrySet()) {
+      DexString methodName = entry.getKey();
+      Map<DexType, DexType> types = entry.getValue();
+      types.forEach(
+          (oldType, newType) -> {
+            DexClass oldClass = appView.definitionFor(oldType);
+            DexLibraryClass newClass = synthesizedLibraryClasses.get(newType);
+            if (oldClass == null || newClass == null) {
+              return;
+            }
+            for (DexEncodedMethod method :
+                oldClass.methods(method -> method.getName() == methodName)) {
+              DexMethod retargetMethod = method.getReference().withHolder(newType, dexItemFactory);
+              if (!method.isStatic()) {
+                retargetMethod = retargetMethod.withExtraArgumentPrepended(oldType, dexItemFactory);
+              }
+              synthesizedMembers
+                  .computeIfAbsent(
+                      newClass,
+                      ignore ->
+                          new TreeSet<>((x, y) -> x.getReference().slowCompareTo(y.getReference())))
+                  .add(
+                      new DexEncodedMethod(
+                          retargetMethod,
+                          MethodAccessFlags.fromCfAccessFlags(
+                              Constants.ACC_PUBLIC | Constants.ACC_STATIC, false),
+                          MethodTypeSignature.noSignature(),
+                          DexAnnotationSet.empty(),
+                          ParameterAnnotationsList.empty(),
+                          null,
+                          true));
+            }
+          });
+    }
+    return synthesizedMembers;
+  }
+
   private static void warnMissingRetargetCoreLibraryMember(DexType type, AppView<?> appView) {
     StringDiagnostic warning =
         new StringDiagnostic(
@@ -155,25 +268,12 @@
       }
 
       InvokeMethod invoke = instruction.asInvokeMethod();
-      DexMethod retarget = getRetargetLibraryMember(invoke.getInvokedMethod());
+      DexMethod invokedMethod = invoke.getInvokedMethod();
+      boolean isInterface = invoke.getInterfaceBit();
+
+      DexMethod retarget = getRetargetedMethod(invokedMethod, isInterface);
       if (retarget == null) {
-        if (!matchesNonFinalHolderRewrite(invoke.getInvokedMethod())) {
-          continue;
-        }
-        // We need to force resolution, even on d8, to know if the invoke has to be rewritten.
-        ResolutionResult resolutionResult =
-            appView
-                .appInfoForDesugaring()
-                .resolveMethod(invoke.getInvokedMethod(), invoke.getInterfaceBit());
-        if (resolutionResult.isFailedResolution()) {
-          continue;
-        }
-        DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
-        assert singleTarget != null;
-        retarget = getRetargetLibraryMember(singleTarget.method);
-        if (retarget == null) {
-          continue;
-        }
+        continue;
       }
 
       // Due to emulated dispatch, we have to rewrite invoke-super differently or we end up in
@@ -203,6 +303,28 @@
     }
   }
 
+  public DexMethod getRetargetedMethod(DexMethod invokedMethod, boolean isInterface) {
+    DexMethod retarget = getRetargetLibraryMember(invokedMethod);
+    if (retarget == null) {
+      if (!matchesNonFinalHolderRewrite(invokedMethod)) {
+        return null;
+      }
+      // We need to force resolution, even on d8, to know if the invoke has to be rewritten.
+      ResolutionResult resolutionResult =
+          appView.appInfoForDesugaring().resolveMethod(invokedMethod, isInterface);
+      if (resolutionResult.isFailedResolution()) {
+        return null;
+      }
+      DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
+      assert singleTarget != null;
+      retarget = getRetargetLibraryMember(singleTarget.method);
+      if (retarget == null) {
+        return null;
+      }
+    }
+    return retarget;
+  }
+
   private DexMethod getRetargetLibraryMember(DexMethod method) {
     Map<DexType, DexType> backportCoreLibraryMembers =
         appView.options().desugaredLibraryConfiguration.getBackportCoreLibraryMember();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index ee05401..4a3ee89 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -209,6 +209,10 @@
     return emulatedInterfaces.containsKey(itf);
   }
 
+  public boolean needsRewriting(DexMethod method) {
+    return emulatedMethods.contains(method.getName());
+  }
+
   DexType getEmulatedInterface(DexType itf) {
     return emulatedInterfaces.get(itf);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index f172fa9..6f945bd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -27,64 +27,25 @@
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
 import com.android.tools.r8.ir.optimize.inliner.InliningIRProvider;
 import com.android.tools.r8.ir.optimize.string.StringOptimizer;
-import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import com.google.common.collect.Streams;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
 
 public final class ClassInliner {
 
   enum EligibilityStatus {
-    // Used by InlineCandidateProcessor#isInstanceEligible
-    NON_CLASS_TYPE,
-    NOT_A_SINGLETON_FIELD,
-    RETRIEVAL_MAY_HAVE_SIDE_EFFECTS,
-    UNKNOWN_TYPE,
-    UNUSED_INSTANCE,
-
-    // Used by isClassEligible
-    NON_PROGRAM_CLASS,
-    ABSTRACT_OR_INTERFACE,
-    NEVER_CLASS_INLINE,
-    IS_PINNED_TYPE,
-    HAS_FINALIZER,
-    TRIGGER_CLINIT,
-
-    // Used by InlineCandidateProcessor#isClassAndUsageEligible
-    HAS_CLINIT,
-    HAS_INSTANCE_FIELDS,
-    NON_FINAL_TYPE,
-    NOT_INITIALIZED_AT_INIT,
-    PINNED_FIELD,
-
-    ELIGIBLE
+    ELIGIBLE,
+    NOT_ELIGIBLE
   }
 
   private final ConcurrentHashMap<DexClass, EligibilityStatus> knownClasses =
       new ConcurrentHashMap<>();
 
-  private void logEligibilityStatus(
-      DexEncodedMethod context, Instruction root, EligibilityStatus status) {
-    if (Log.ENABLED && Log.isLoggingEnabledFor(ClassInliner.class)) {
-      Log.info(getClass(), "At %s,", context.toSourceString());
-      Log.info(getClass(), "ClassInlining eligibility of `%s`: %s.", root, status);
-    }
-  }
-
-  private void logIneligibleUser(
-      DexEncodedMethod context, Instruction root, InstructionOrPhi ineligibleUser) {
-    if (Log.ENABLED && Log.isLoggingEnabledFor(ClassInliner.class)) {
-      Log.info(getClass(), "At %s,", context.toSourceString());
-      Log.info(getClass(), "Ineligible user of `%s`: `%s`.", root, ineligibleUser);
-    }
-  }
-
   // Process method code and inline eligible class instantiations, in short:
   //
   // - collect all 'new-instance' and 'static-get' instructions (called roots below) in
@@ -176,9 +137,7 @@
 
     // Collect all the new-instance and static-get instructions in the code before inlining.
     List<Instruction> roots =
-        Streams.stream(code.instructionIterator())
-            .filter(insn -> insn.isNewInstance() || insn.isStaticGet())
-            .collect(Collectors.toList());
+        Lists.newArrayList(code.instructions(insn -> insn.isNewInstance() || insn.isStaticGet()));
 
     // We loop inlining iterations until there was no inlining, but still use same set
     // of roots to avoid infinite inlining. Looping makes possible for some roots to
@@ -204,13 +163,11 @@
         // Assess eligibility of instance and class.
         EligibilityStatus status = processor.isInstanceEligible();
         if (status != EligibilityStatus.ELIGIBLE) {
-          logEligibilityStatus(code.method(), root, status);
           // This root will never be inlined.
           rootsIterator.remove();
           continue;
         }
         status = processor.isClassAndUsageEligible();
-        logEligibilityStatus(code.method(), root, status);
         if (status != EligibilityStatus.ELIGIBLE) {
           // This root will never be inlined.
           rootsIterator.remove();
@@ -221,7 +178,6 @@
         InstructionOrPhi ineligibleUser = processor.areInstanceUsersEligible(defaultOracle);
         if (ineligibleUser != null) {
           // This root may succeed if users change in future.
-          logIneligibleUser(code.method(), root, ineligibleUser);
           continue;
         }
 
@@ -309,7 +265,8 @@
     }
   }
 
-  private EligibilityStatus isClassEligible(AppView<AppInfoWithLiveness> appView, DexClass clazz) {
+  private EligibilityStatus isClassEligible(
+      AppView<AppInfoWithLiveness> appView, DexProgramClass clazz) {
     EligibilityStatus eligible = knownClasses.get(clazz);
     if (eligible == null) {
       EligibilityStatus computed = computeClassEligible(appView, clazz);
@@ -325,21 +282,12 @@
   //   - does not declare finalizer
   //   - does not trigger any static initializers except for its own
   private EligibilityStatus computeClassEligible(
-      AppView<AppInfoWithLiveness> appView, DexClass clazz) {
-    if (clazz == null) {
-      return EligibilityStatus.UNKNOWN_TYPE;
-    }
-    if (clazz.isNotProgramClass()) {
-      return EligibilityStatus.NON_PROGRAM_CLASS;
-    }
-    if (clazz.isAbstract() || clazz.isInterface()) {
-      return EligibilityStatus.ABSTRACT_OR_INTERFACE;
-    }
-    if (appView.appInfo().neverClassInline.contains(clazz.type)) {
-      return EligibilityStatus.NEVER_CLASS_INLINE;
-    }
-    if (appView.appInfo().isPinned(clazz.type)) {
-      return EligibilityStatus.IS_PINNED_TYPE;
+      AppView<AppInfoWithLiveness> appView, DexProgramClass clazz) {
+    if (clazz == null
+        || clazz.isAbstract()
+        || clazz.isInterface()
+        || !appView.appInfo().isClassInliningAllowed(clazz)) {
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
 
     // Class must not define finalizer.
@@ -347,13 +295,13 @@
     for (DexEncodedMethod method : clazz.virtualMethods()) {
       if (method.method.name == dexItemFactory.finalizeMethodName
           && method.method.proto == dexItemFactory.objectMembers.finalize.proto) {
-        return EligibilityStatus.HAS_FINALIZER;
+        return EligibilityStatus.NOT_ELIGIBLE;
       }
     }
 
     // Check for static initializers in this class or any of interfaces it implements.
     if (clazz.initializationOfParentTypesMayHaveSideEffects(appView)) {
-      return EligibilityStatus.TRIGGER_CLINIT;
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
     return EligibilityStatus.ELIGIBLE;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index b917507..c8cc00e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AccessControl;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
@@ -95,7 +94,7 @@
   private final AppView<AppInfoWithLiveness> appView;
   private final DexItemFactory dexItemFactory;
   private final Inliner inliner;
-  private final Function<DexClass, EligibilityStatus> isClassEligible;
+  private final Function<DexProgramClass, EligibilityStatus> isClassEligible;
   private final MethodProcessor methodProcessor;
   private final ProgramMethod method;
   private final Instruction root;
@@ -122,7 +121,7 @@
   InlineCandidateProcessor(
       AppView<AppInfoWithLiveness> appView,
       Inliner inliner,
-      Function<DexClass, EligibilityStatus> isClassEligible,
+      Function<DexProgramClass, EligibilityStatus> isClassEligible,
       MethodProcessor methodProcessor,
       ProgramMethod method,
       Instruction root) {
@@ -157,20 +156,20 @@
   EligibilityStatus isInstanceEligible() {
     eligibleInstance = root.outValue();
     if (eligibleInstance == null) {
-      return EligibilityStatus.UNUSED_INSTANCE;
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
 
     if (root.isNewInstance()) {
       eligibleClass = asProgramClassOrNull(appView.definitionFor(root.asNewInstance().clazz));
       if (eligibleClass == null) {
-        return EligibilityStatus.UNKNOWN_TYPE;
+        return EligibilityStatus.NOT_ELIGIBLE;
       }
       if (eligibleClass.classInitializationMayHaveSideEffects(
           appView,
           // Types that are a super type of the current context are guaranteed to be initialized.
           type -> appView.isSubtype(method.getHolderType(), type).isTrue(),
           Sets.newIdentityHashSet())) {
-        return EligibilityStatus.HAS_CLINIT;
+        return EligibilityStatus.NOT_ELIGIBLE;
       }
       return EligibilityStatus.ELIGIBLE;
     }
@@ -179,19 +178,19 @@
 
     StaticGet staticGet = root.asStaticGet();
     if (staticGet.instructionMayHaveSideEffects(appView, method)) {
-      return EligibilityStatus.RETRIEVAL_MAY_HAVE_SIDE_EFFECTS;
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
     DexEncodedField field = appView.appInfo().resolveField(staticGet.getField()).getResolvedField();
     FieldOptimizationInfo optimizationInfo = field.getOptimizationInfo();
     ClassTypeElement dynamicLowerBoundType = optimizationInfo.getDynamicLowerBoundType();
     if (dynamicLowerBoundType == null
         || !dynamicLowerBoundType.equals(optimizationInfo.getDynamicUpperBoundType())) {
-      return EligibilityStatus.NOT_A_SINGLETON_FIELD;
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
     eligibleClass =
         asProgramClassOrNull(appView.definitionFor(dynamicLowerBoundType.getClassType()));
     if (eligibleClass == null) {
-      return EligibilityStatus.UNKNOWN_TYPE;
+      return EligibilityStatus.NOT_ELIGIBLE;
     }
     return EligibilityStatus.ELIGIBLE;
   }
@@ -313,7 +312,7 @@
 
           if (AccessControl.isClassAccessible(singleTarget.getHolder(), method, appView)
               .isPossiblyFalse()) {
-            continue;
+            return user; // Not eligible.
           }
 
           // Eligible constructor call (for new instance roots only).
diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
index 9d4121c..fb120e0 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
@@ -5,7 +5,8 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexClassAndField;
+import com.android.tools.r8.graph.DexDefinitionSupplier;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
@@ -48,7 +49,7 @@
   }
 
   private DexMethod validTargetFor(DexMethod target, DexMethod original) {
-    DexClass clazz = appView.definitionFor(target.holder);
+    DexClass clazz = appView.definitionFor(target.getHolderType());
     assert clazz != null;
     if (clazz.isProgramClass()) {
       return target;
@@ -56,36 +57,38 @@
     DexType newHolder;
     if (clazz.isInterface()) {
       newHolder =
-          firstLibraryClassForInterfaceTarget(target, original.holder, DexClass::lookupMethod);
+          firstLibraryClassForInterfaceTarget(
+              appView, target, original.holder, DexClass::lookupMethod);
     } else {
-      newHolder = firstLibraryClass(target.holder, original.holder);
+      newHolder = firstLibraryClass(appView, target.getHolderType(), original.getHolderType());
     }
     return newHolder == null
         ? original
         : appView.dexItemFactory().createMethod(newHolder, original.proto, original.name);
   }
 
-  private DexField validTargetFor(DexField target, DexField original,
-      BiFunction<DexClass, DexField, DexEncodedField> lookup) {
-    DexClass clazz = appView.definitionFor(target.holder);
-    assert clazz != null;
-    if (clazz.isProgramClass()) {
-      return target;
+  public static DexField validMemberRebindingTargetFor(
+      DexDefinitionSupplier definitions, DexClassAndField field, DexField original) {
+    DexClass clazz = field.getHolder();
+    if (field.isProgramField()) {
+      return field.getReference();
     }
-    DexType newHolder;
-    if (clazz.isInterface()) {
-      newHolder = firstLibraryClassForInterfaceTarget(target, original.holder, lookup);
-    } else {
-      newHolder = firstLibraryClass(target.holder, original.holder);
-    }
-    return newHolder == null
-        ? original
-        : appView.dexItemFactory().createField(newHolder, original.type, original.name);
+    DexType newHolder =
+        clazz.isInterface()
+            ? firstLibraryClassForInterfaceTarget(
+                definitions, field.getReference(), original.getHolderType(), DexClass::lookupField)
+            : firstLibraryClass(definitions, field.getHolderType(), original.getHolderType());
+    return newHolder != null
+        ? field.getReference().withHolder(newHolder, definitions.dexItemFactory())
+        : original;
   }
 
-  private <T> DexType firstLibraryClassForInterfaceTarget(T target, DexType current,
+  private static <T> DexType firstLibraryClassForInterfaceTarget(
+      DexDefinitionSupplier definitions,
+      T target,
+      DexType current,
       BiFunction<DexClass, T, ?> lookup) {
-    DexClass clazz = appView.definitionFor(current);
+    DexClass clazz = definitions.definitionFor(current);
     if (clazz == null) {
       return null;
     }
@@ -95,14 +98,16 @@
       return current;
     }
     if (clazz.superType != null) {
-      DexType matchingSuper = firstLibraryClassForInterfaceTarget(target, clazz.superType, lookup);
+      DexType matchingSuper =
+          firstLibraryClassForInterfaceTarget(definitions, target, clazz.superType, lookup);
       if (matchingSuper != null) {
         // Found in supertype, return first library class.
         return clazz.isNotProgramClass() ? current : matchingSuper;
       }
     }
     for (DexType iface : clazz.interfaces.values) {
-      DexType matchingIface = firstLibraryClassForInterfaceTarget(target, iface, lookup);
+      DexType matchingIface =
+          firstLibraryClassForInterfaceTarget(definitions, target, iface, lookup);
       if (matchingIface != null) {
         // Found in interface, return first library class.
         return clazz.isNotProgramClass() ? current : matchingIface;
@@ -111,11 +116,12 @@
     return null;
   }
 
-  private DexType firstLibraryClass(DexType top, DexType bottom) {
-    assert appView.definitionFor(top).isNotProgramClass();
-    DexClass searchClass = appView.definitionFor(bottom);
+  private static DexType firstLibraryClass(
+      DexDefinitionSupplier definitions, DexType top, DexType bottom) {
+    assert definitions.definitionFor(top).isNotProgramClass();
+    DexClass searchClass = definitions.definitionFor(bottom);
     while (searchClass.isProgramClass()) {
-      searchClass = appView.definitionFor(searchClass.superType);
+      searchClass = definitions.definitionFor(searchClass.superType);
     }
     return searchClass.type;
   }
diff --git a/src/main/java/com/android/tools/r8/repackaging/RepackagingTreeFixer.java b/src/main/java/com/android/tools/r8/repackaging/RepackagingTreeFixer.java
index 8820838..a5a77d7 100644
--- a/src/main/java/com/android/tools/r8/repackaging/RepackagingTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/repackaging/RepackagingTreeFixer.java
@@ -241,7 +241,6 @@
     for (DexProgramClass clazz : synthesizedFrom) {
       // TODO(b/165783399): What do we want to put here if the class that this was synthesized from
       //  is no longer in the application?
-      assert appView.definitionFor(clazz.type) != null;
       DexProgramClass newClass =
           newProgramClasses.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz));
       newSynthesizedFrom.add(newClass);
diff --git a/src/main/java/com/android/tools/r8/retrace/Result.java b/src/main/java/com/android/tools/r8/retrace/Result.java
deleted file mode 100644
index 692ca9b..0000000
--- a/src/main/java/com/android/tools/r8/retrace/Result.java
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2019, 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.retrace;
-
-import com.android.tools.r8.Keep;
-import java.util.function.Consumer;
-import java.util.stream.Stream;
-
-@Keep
-public abstract class Result<R, RR extends Result<R, RR>> {
-
-  public abstract Stream<R> stream();
-
-  public abstract RR forEach(Consumer<R> resultConsumer);
-
-  public abstract boolean isAmbiguous();
-}
diff --git a/src/main/java/com/android/tools/r8/retrace/Retrace.java b/src/main/java/com/android/tools/r8/retrace/Retrace.java
index b8d94e6..9b838df 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -12,6 +12,13 @@
 import com.android.tools.r8.Version;
 import com.android.tools.r8.retrace.RetraceCommand.Builder;
 import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
+import com.android.tools.r8.retrace.internal.PlainStackTraceVisitor;
+import com.android.tools.r8.retrace.internal.RetraceAbortException;
+import com.android.tools.r8.retrace.internal.RetraceCommandLineResult;
+import com.android.tools.r8.retrace.internal.RetraceRegularExpression;
+import com.android.tools.r8.retrace.internal.RetracerImpl;
+import com.android.tools.r8.retrace.internal.StackTraceElementProxyRetracerImpl;
+import com.android.tools.r8.retrace.internal.StackTraceElementStringProxy;
 import com.android.tools.r8.utils.ExceptionDiagnostic;
 import com.android.tools.r8.utils.OptionsParsing;
 import com.android.tools.r8.utils.OptionsParsing.ParseContext;
@@ -157,8 +164,8 @@
     try {
       Timing timing = Timing.create("R8 retrace", command.printMemory());
       timing.begin("Read proguard map");
-      RetraceApi retracer =
-          Retracer.create(command.proguardMapProducer, command.diagnosticsHandler);
+      RetracerImpl retracer =
+          RetracerImpl.create(command.proguardMapProducer, command.diagnosticsHandler);
       timing.end();
       RetraceCommandLineResult result;
       timing.begin("Parse and Retrace");
@@ -175,7 +182,7 @@
         PlainStackTraceVisitor plainStackTraceVisitor =
             new PlainStackTraceVisitor(command.stackTrace, command.diagnosticsHandler);
         StackTraceElementProxyRetracer<StackTraceElementStringProxy> proxyRetracer =
-            new StackTraceElementProxyRetracer<>(retracer);
+            new StackTraceElementProxyRetracerImpl<>(retracer);
         List<String> retracedStrings = new ArrayList<>();
         plainStackTraceVisitor.forEach(
             stackTraceElement -> {
@@ -274,8 +281,6 @@
     return readLines;
   }
 
-  static class RetraceAbortException extends RuntimeException {}
-
   private interface MainAction {
     void run() throws RetraceAbortException;
   }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceApi.java b/src/main/java/com/android/tools/r8/retrace/RetraceApi.java
deleted file mode 100644
index 7a1eb4e..0000000
--- a/src/main/java/com/android/tools/r8/retrace/RetraceApi.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2019, 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.retrace;
-
-import com.android.tools.r8.Keep;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.TypeReference;
-
-/** This is the main api interface for retrace. */
-@Keep
-public interface RetraceApi {
-
-  // TODO(b/170711681): Rename these to not have overloads.
-
-  RetraceClassResult retrace(ClassReference classReference);
-
-  RetraceMethodResult retrace(MethodReference methodReference);
-
-  RetraceFieldResult retrace(FieldReference fieldReference);
-
-  RetraceFrameResult retrace(MethodReference methodReference, int position);
-
-  RetraceTypeResult retrace(TypeReference typeReference);
-}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceClassMemberElement.java b/src/main/java/com/android/tools/r8/retrace/RetraceClassMemberElement.java
deleted file mode 100644
index c21a100..0000000
--- a/src/main/java/com/android/tools/r8/retrace/RetraceClassMemberElement.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2020, 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.retrace;
-
-import java.util.function.BiConsumer;
-
-public interface RetraceClassMemberElement<T extends RetracedClassMember> {
-
-  boolean isUnknown();
-
-  default boolean isFrameElement() {
-    return false;
-  }
-
-  default RetraceFrameResult.Element asFrameElement() {
-    return null;
-  }
-
-  RetraceClassResult.Element getClassElement();
-
-  T getMember();
-
-  void visitFrames(BiConsumer<T, Integer> consumer);
-
-  RetraceSourceFileResult retraceSourceFile(RetracedClassMember frame, String sourceFile);
-}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
index 795311e..f9d0d6f 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
@@ -1,244 +1,58 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
 
-import static com.android.tools.r8.naming.MemberNaming.NoSignature.NO_SIGNATURE;
-import static com.android.tools.r8.retrace.RetraceUtils.synthesizeFileName;
-
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.naming.ClassNamingForNameMapper;
-import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
-import com.android.tools.r8.naming.MemberNaming;
-import com.android.tools.r8.naming.mappinginformation.MappingInformation;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.retrace.RetraceClassResult.Element;
-import com.android.tools.r8.utils.Pair;
-import com.google.common.collect.ImmutableList;
-import java.util.ArrayList;
 import java.util.List;
-import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 @Keep
-public class RetraceClassResult extends Result<Element, RetraceClassResult> {
+public interface RetraceClassResult {
 
-  private final ClassReference obfuscatedReference;
-  private final ClassNamingForNameMapper mapper;
-  private final RetraceApi retracer;
+  RetraceFieldResult lookupField(String fieldName);
 
-  private RetraceClassResult(
-      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetraceApi retracer) {
-    this.obfuscatedReference = obfuscatedReference;
-    this.mapper = mapper;
-    this.retracer = retracer;
-  }
+  RetraceFieldResult lookupField(String fieldName, TypeReference fieldType);
 
-  static RetraceClassResult create(
-      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetraceApi retracer) {
-    return new RetraceClassResult(obfuscatedReference, mapper, retracer);
-  }
+  RetraceMethodResult lookupMethod(String methodName);
 
-  public RetraceFieldResult lookupField(String fieldName) {
-    return lookupField(FieldDefinition.create(obfuscatedReference, fieldName));
-  }
+  RetraceMethodResult lookupMethod(
+      String methodName, List<TypeReference> formalTypes, TypeReference returnType);
 
-  public RetraceFieldResult lookupField(String fieldName, TypeReference fieldType) {
-    return lookupField(
-        FieldDefinition.create(Reference.field(obfuscatedReference, fieldName, fieldType)));
-  }
+  RetraceFrameResult lookupFrame(String methodName);
 
-  public RetraceMethodResult lookupMethod(String methodName) {
-    return lookupMethod(MethodDefinition.create(obfuscatedReference, methodName));
-  }
+  RetraceFrameResult lookupFrame(String methodName, int position);
 
-  public RetraceMethodResult lookupMethod(
-      String methodName, List<TypeReference> formalTypes, TypeReference returnType) {
-    return lookupMethod(
-        MethodDefinition.create(
-            Reference.method(obfuscatedReference, methodName, formalTypes, returnType)));
-  }
+  RetraceFrameResult lookupFrame(
+      String methodName, int position, List<TypeReference> formalTypes, TypeReference returnType);
 
-  private RetraceFieldResult lookupField(FieldDefinition fieldDefinition) {
-    return lookup(
-        fieldDefinition,
-        (mapper, name) -> {
-          List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
-          if (memberNamings == null || memberNamings.isEmpty()) {
-            return null;
-          }
-          return memberNamings;
-        },
-        RetraceFieldResult::new);
-  }
+  Stream<Element> stream();
 
-  private RetraceMethodResult lookupMethod(MethodDefinition methodDefinition) {
-    return lookup(
-        methodDefinition,
-        (mapper, name) -> {
-          MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
-          if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
-            return null;
-          }
-          return mappedRanges.getMappedRanges();
-        },
-        RetraceMethodResult::new);
-  }
+  RetraceClassResult forEach(Consumer<Element> resultConsumer);
 
-  private <T, R, D extends Definition> R lookup(
-      D definition,
-      BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
-      ResultConstructor<T, R, D> constructor) {
-    List<Pair<Element, T>> mappings = new ArrayList<>();
-    forEach(
-        element -> {
-          if (mapper != null) {
-            assert element.mapper != null;
-            T mappedElements = lookupFunction.apply(element.mapper, definition.getName());
-            if (mappedElements != null) {
-              mappings.add(new Pair<>(element, mappedElements));
-              return;
-            }
-          }
-          mappings.add(new Pair<>(element, null));
-        });
-    return constructor.create(this, mappings, definition, retracer);
-  }
+  boolean isAmbiguous();
 
-  boolean hasRetraceResult() {
-    return mapper != null;
-  }
+  @Keep
+  interface Element {
 
-  @Override
-  public Stream<Element> stream() {
-    return Stream.of(
-        new Element(
-            this,
-            RetracedClass.create(
-                mapper == null
-                    ? obfuscatedReference
-                    : Reference.classFromTypeName(mapper.originalName)),
-            mapper));
-  }
+    RetracedClass getRetracedClass();
 
-  @Override
-  public RetraceClassResult forEach(Consumer<Element> resultConsumer) {
-    stream().forEach(resultConsumer);
-    return this;
-  }
+    RetraceClassResult getRetraceClassResult();
 
-  private interface ResultConstructor<T, R, D> {
-    R create(
-        RetraceClassResult classResult,
-        List<Pair<Element, T>> mappings,
-        D definition,
-        RetraceApi retraceApi);
-  }
+    RetraceSourceFileResult retraceSourceFile(String sourceFile);
 
-  @Override
-  public boolean isAmbiguous() {
-    // Currently we have no way of producing ambiguous class results.
-    return false;
-  }
+    RetraceFieldResult lookupField(String fieldName);
 
-  public static class Element {
+    RetraceMethodResult lookupMethod(String methodName);
 
-    private final RetraceClassResult classResult;
-    private final RetracedClass classReference;
-    private final ClassNamingForNameMapper mapper;
+    RetraceFrameResult lookupFrame(String methodName);
 
-    public Element(
-        RetraceClassResult classResult,
-        RetracedClass classReference,
-        ClassNamingForNameMapper mapper) {
-      this.classResult = classResult;
-      this.classReference = classReference;
-      this.mapper = mapper;
-    }
+    RetraceFrameResult lookupFrame(String methodName, int position);
 
-    public RetracedClass getRetracedClass() {
-      return classReference;
-    }
-
-    public RetraceClassResult getRetraceClassResult() {
-      return classResult;
-    }
-
-    public RetraceSourceFileResult retraceSourceFile(String sourceFile) {
-      if (mapper != null && mapper.getAdditionalMappings().size() > 0) {
-        List<MappingInformation> mappingInformations =
-            mapper.getAdditionalMappings().get(NO_SIGNATURE);
-        if (mappingInformations != null) {
-          for (MappingInformation mappingInformation : mappingInformations) {
-            if (mappingInformation.isFileNameInformation()) {
-              return new RetraceSourceFileResult(
-                  mappingInformation.asFileNameInformation().getFileName(), false);
-            }
-          }
-        }
-      }
-      return new RetraceSourceFileResult(
-          synthesizeFileName(
-              classReference.getTypeName(),
-              classResult.obfuscatedReference.getTypeName(),
-              sourceFile,
-              mapper != null),
-          true);
-    }
-
-    public RetraceFieldResult lookupField(String fieldName) {
-      return lookupField(FieldDefinition.create(classReference.getClassReference(), fieldName));
-    }
-
-    private RetraceFieldResult lookupField(FieldDefinition fieldDefinition) {
-      return lookup(
-          fieldDefinition,
-          (mapper, name) -> {
-            List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
-            if (memberNamings == null || memberNamings.isEmpty()) {
-              return null;
-            }
-            return memberNamings;
-          },
-          RetraceFieldResult::new);
-    }
-
-    public RetraceMethodResult lookupMethod(String methodName) {
-      return lookupMethod(MethodDefinition.create(classReference.getClassReference(), methodName));
-    }
-
-    private RetraceMethodResult lookupMethod(MethodDefinition methodDefinition) {
-      return lookup(
-          methodDefinition,
-          (mapper, name) -> {
-            MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
-            if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
-              return null;
-            }
-            return mappedRanges.getMappedRanges();
-          },
-          RetraceMethodResult::new);
-    }
-
-    private <T, R, D extends Definition> R lookup(
-        D definition,
-        BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
-        ResultConstructor<T, R, D> constructor) {
-      List<Pair<Element, T>> mappings = ImmutableList.of();
-      if (mapper != null) {
-        T result = lookupFunction.apply(mapper, definition.getName());
-        if (result != null) {
-          mappings = ImmutableList.of(new Pair<>(this, result));
-        }
-      }
-      if (mappings.isEmpty()) {
-        mappings = ImmutableList.of(new Pair<>(this, null));
-      }
-      return constructor.create(classResult, mappings, definition, classResult.retracer);
-    }
+    RetraceFrameResult lookupFrame(
+        String methodName, int position, List<TypeReference> formalTypes, TypeReference returnType);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
index 46f247d..f141080 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
@@ -1,129 +1,31 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
 
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.naming.MemberNaming;
-import com.android.tools.r8.naming.MemberNaming.FieldSignature;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.Pair;
-import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 @Keep
-public class RetraceFieldResult extends Result<RetraceFieldResult.Element, RetraceFieldResult> {
+public interface RetraceFieldResult {
 
-  private final RetraceClassResult classResult;
-  private final List<Pair<RetraceClassResult.Element, List<MemberNaming>>> memberNamings;
-  private final FieldDefinition fieldDefinition;
-  private final RetraceApi retracer;
+  Stream<Element> stream();
 
-  RetraceFieldResult(
-      RetraceClassResult classResult,
-      List<Pair<RetraceClassResult.Element, List<MemberNaming>>> memberNamings,
-      FieldDefinition fieldDefinition,
-      RetraceApi retracer) {
-    this.classResult = classResult;
-    this.memberNamings = memberNamings;
-    this.fieldDefinition = fieldDefinition;
-    this.retracer = retracer;
-    assert classResult != null;
-    assert !memberNamings.isEmpty();
-  }
+  RetraceFieldResult forEach(Consumer<Element> resultConsumer);
 
-  @Override
-  public boolean isAmbiguous() {
-    if (memberNamings.size() > 1) {
-      return true;
-    }
-    List<MemberNaming> mappings = memberNamings.get(0).getSecond();
-    if (mappings == null) {
-      return false;
-    }
-    return mappings.size() > 1;
-  }
+  boolean isAmbiguous();
 
-  @Override
-  public Stream<Element> stream() {
-    return memberNamings.stream()
-        .flatMap(
-            mappedNamePair -> {
-              RetraceClassResult.Element classElement = mappedNamePair.getFirst();
-              List<MemberNaming> memberNamings = mappedNamePair.getSecond();
-              if (memberNamings == null) {
-                return Stream.of(
-                    new RetraceFieldResult.Element(
-                        this,
-                        classElement,
-                        RetracedField.create(
-                            fieldDefinition.substituteHolder(
-                                classElement.getRetracedClass().getClassReference()))));
-              }
-              return memberNamings.stream()
-                  .map(
-                      memberNaming -> {
-                        FieldSignature fieldSignature =
-                            memberNaming.getOriginalSignature().asFieldSignature();
-                        RetracedClass holder =
-                            fieldSignature.isQualified()
-                                ? RetracedClass.create(
-                                    Reference.classFromDescriptor(
-                                        DescriptorUtils.javaTypeToDescriptor(
-                                            fieldSignature.toHolderFromQualified())))
-                                : classElement.getRetracedClass();
-                        return new Element(
-                            this,
-                            classElement,
-                            RetracedField.create(
-                                Reference.field(
-                                    holder.getClassReference(),
-                                    fieldSignature.isQualified()
-                                        ? fieldSignature.toUnqualifiedName()
-                                        : fieldSignature.name,
-                                    Reference.typeFromTypeName(fieldSignature.type))));
-                      });
-            });
-  }
+  @Keep
+  interface Element {
 
-  @Override
-  public RetraceFieldResult forEach(Consumer<Element> resultConsumer) {
-    stream().forEach(resultConsumer);
-    return this;
-  }
+    boolean isUnknown();
 
-  public static class Element {
+    RetracedField getField();
 
-    private final RetracedField fieldReference;
-    private final RetraceFieldResult retraceFieldResult;
-    private final RetraceClassResult.Element classElement;
+    RetraceFieldResult getRetraceFieldResult();
 
-    private Element(
-        RetraceFieldResult retraceFieldResult,
-        RetraceClassResult.Element classElement,
-        RetracedField fieldReference) {
-      this.classElement = classElement;
-      this.fieldReference = fieldReference;
-      this.retraceFieldResult = retraceFieldResult;
-    }
-
-    public boolean isUnknown() {
-      return fieldReference.isUnknown();
-    }
-
-    public RetracedField getField() {
-      return fieldReference;
-    }
-
-    public RetraceFieldResult getRetraceFieldResult() {
-      return retraceFieldResult;
-    }
-
-    public RetraceClassResult.Element getClassElement() {
-      return classElement;
-    }
+    RetraceClassResult.Element getClassElement();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceFrameResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceFrameResult.java
index 95dc9d5..b439d94 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceFrameResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceFrameResult.java
@@ -4,161 +4,34 @@
 
 package com.android.tools.r8.retrace;
 
-import static com.android.tools.r8.retrace.RetraceUtils.methodReferenceFromMappedRange;
-
-import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.utils.Pair;
-import com.google.common.collect.ImmutableList;
-import java.util.ArrayList;
-import java.util.Collections;
+import com.android.tools.r8.Keep;
 import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
-public class RetraceFrameResult extends Result<RetraceFrameResult.Element, RetraceFrameResult> {
+@Keep
+public interface RetraceFrameResult {
 
-  private final RetraceClassResult classResult;
-  private final MethodDefinition methodDefinition;
-  private final int obfuscatedPosition;
-  private final List<Pair<RetraceClassResult.Element, List<MappedRange>>> mappedRanges;
-  private final RetraceApi retracer;
+  Stream<Element> stream();
 
-  public RetraceFrameResult(
-      RetraceClassResult classResult,
-      List<Pair<RetraceClassResult.Element, List<MappedRange>>> mappedRanges,
-      MethodDefinition methodDefinition,
-      int obfuscatedPosition,
-      RetraceApi retracer) {
-    this.classResult = classResult;
-    this.methodDefinition = methodDefinition;
-    this.obfuscatedPosition = obfuscatedPosition;
-    this.mappedRanges = mappedRanges;
-    this.retracer = retracer;
-  }
+  RetraceFrameResult forEach(Consumer<Element> resultConsumer);
 
-  @Override
-  public boolean isAmbiguous() {
-    return mappedRanges.size() > 1;
-  }
+  boolean isAmbiguous();
 
-  @Override
-  public Stream<Element> stream() {
-    return mappedRanges.stream()
-        .map(
-            mappedRangePair -> {
-              RetraceClassResult.Element classElement = mappedRangePair.getFirst();
-              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
-              if (mappedRanges == null || mappedRanges.isEmpty()) {
-                return new Element(
-                    this,
-                    classElement,
-                    RetracedMethod.create(
-                        methodDefinition.substituteHolder(
-                            classElement.getRetracedClass().getClassReference())),
-                    ImmutableList.of(),
-                    obfuscatedPosition);
-              }
-              MappedRange mappedRange = mappedRanges.get(0);
-              MethodReference methodReference =
-                  methodReferenceFromMappedRange(
-                      mappedRange, classElement.getRetracedClass().getClassReference());
-              RetracedMethod retracedMethod =
-                  RetracedMethod.create(
-                      methodReference, mappedRange.getOriginalLineNumber(obfuscatedPosition));
-              return new Element(
-                  this, classElement, retracedMethod, mappedRanges, obfuscatedPosition);
-            });
-  }
+  @Keep
+  interface Element {
 
-  @Override
-  public RetraceFrameResult forEach(Consumer<Element> resultConsumer) {
-    stream().forEach(resultConsumer);
-    return this;
-  }
+    boolean isUnknown();
 
-  public static class Element implements RetraceClassMemberElement<RetracedMethod> {
+    RetracedMethod getTopFrame();
 
-    private final RetracedMethod methodReference;
-    private final RetraceFrameResult retraceFrameResult;
-    private final RetraceClassResult.Element classElement;
-    private final List<MappedRange> mappedRanges;
-    private final int obfuscatedPosition;
+    RetraceClassResult.Element getClassElement();
 
-    public Element(
-        RetraceFrameResult retraceFrameResult,
-        RetraceClassResult.Element classElement,
-        RetracedMethod methodReference,
-        List<MappedRange> mappedRanges,
-        int obfuscatedPosition) {
-      this.methodReference = methodReference;
-      this.retraceFrameResult = retraceFrameResult;
-      this.classElement = classElement;
-      this.mappedRanges = mappedRanges;
-      this.obfuscatedPosition = obfuscatedPosition;
-    }
+    void visitFrames(BiConsumer<RetracedMethod, Integer> consumer);
 
-    @Override
-    public boolean isUnknown() {
-      return methodReference.isUnknown();
-    }
+    RetraceSourceFileResult retraceSourceFile(RetracedClassMember frame, String sourceFile);
 
-    @Override
-    public boolean isFrameElement() {
-      return true;
-    }
-
-    @Override
-    public Element asFrameElement() {
-      return this;
-    }
-
-    @Override
-    public RetracedMethod getMember() {
-      return methodReference;
-    }
-
-    public RetracedMethod getTopFrame() {
-      return methodReference;
-    }
-
-    @Override
-    public RetraceClassResult.Element getClassElement() {
-      return classElement;
-    }
-
-    @Override
-    public void visitFrames(BiConsumer<RetracedMethod, Integer> consumer) {
-      int counter = 0;
-      consumer.accept(methodReference, counter++);
-      for (RetracedMethod outerFrame : getOuterFrames()) {
-        consumer.accept(outerFrame, counter++);
-      }
-    }
-
-    @Override
-    public RetraceSourceFileResult retraceSourceFile(RetracedClassMember frame, String sourceFile) {
-      return RetraceUtils.getSourceFile(
-          classElement, frame.getHolderClass(), sourceFile, retraceFrameResult.retracer);
-    }
-
-    public List<RetracedMethod> getOuterFrames() {
-      if (mappedRanges == null) {
-        return Collections.emptyList();
-      }
-      List<RetracedMethod> outerFrames = new ArrayList<>();
-      for (int i = 1; i < mappedRanges.size(); i++) {
-        MappedRange mappedRange = mappedRanges.get(i);
-        MethodReference methodReference =
-            methodReferenceFromMappedRange(
-                mappedRange, classElement.getRetracedClass().getClassReference());
-        outerFrames.add(
-            RetracedMethod.create(
-                MethodDefinition.create(methodReference),
-                mappedRange.getOriginalLineNumber(obfuscatedPosition)));
-      }
-      return outerFrames;
-    }
+    List<? extends RetracedMethod> getOuterFrames();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
index 0906420..20c73e3 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
@@ -1,174 +1,35 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
 
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
-import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.utils.Pair;
-import com.google.common.collect.ImmutableList;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 @Keep
-public class RetraceMethodResult extends Result<RetraceMethodResult.Element, RetraceMethodResult> {
+public interface RetraceMethodResult {
 
-  private final MethodDefinition methodDefinition;
-  private final RetraceClassResult classResult;
-  private final List<Pair<RetraceClassResult.Element, List<MappedRange>>> mappedRanges;
-  private final RetraceApi retracer;
+  RetraceFrameResult narrowByPosition(int position);
 
-  RetraceMethodResult(
-      RetraceClassResult classResult,
-      List<Pair<RetraceClassResult.Element, List<MappedRange>>> mappedRanges,
-      MethodDefinition methodDefinition,
-      RetraceApi retracer) {
-    this.classResult = classResult;
-    this.mappedRanges = mappedRanges;
-    this.methodDefinition = methodDefinition;
-    this.retracer = retracer;
-    assert classResult != null;
-    assert !mappedRanges.isEmpty();
-  }
+  Stream<Element> stream();
 
-  @Override
-  public boolean isAmbiguous() {
-    if (mappedRanges.size() > 1) {
-      return true;
-    }
-    List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
-    if (methodRanges == null || methodRanges.isEmpty()) {
-      return false;
-    }
-    MappedRange lastRange = methodRanges.get(0);
-    for (MappedRange mappedRange : methodRanges) {
-      if (mappedRange != lastRange
-          && (mappedRange.minifiedRange == null
-              || !mappedRange.minifiedRange.equals(lastRange.minifiedRange))) {
-        return true;
-      }
-    }
-    return false;
-  }
+  RetraceMethodResult forEach(Consumer<Element> resultConsumer);
 
-  public RetraceFrameResult narrowByPosition(int position) {
-    List<Pair<RetraceClassResult.Element, List<MappedRange>>> narrowedRanges = new ArrayList<>();
-    List<Pair<RetraceClassResult.Element, List<MappedRange>>> noMappingRanges = new ArrayList<>();
-    for (Pair<RetraceClassResult.Element, List<MappedRange>> mappedRange : mappedRanges) {
-      if (mappedRange.getSecond() == null) {
-        noMappingRanges.add(new Pair<>(mappedRange.getFirst(), null));
-        continue;
-      }
-      List<MappedRange> ranges =
-          new MappedRangesOfName(mappedRange.getSecond()).allRangesForLine(position, false);
-      boolean hasAddedRanges = false;
-      if (!ranges.isEmpty()) {
-        narrowedRanges.add(new Pair<>(mappedRange.getFirst(), ranges));
-        hasAddedRanges = true;
-      } else {
-        narrowedRanges = new ArrayList<>();
-        for (MappedRange mapped : mappedRange.getSecond()) {
-          if (mapped.minifiedRange == null) {
-            narrowedRanges.add(new Pair<>(mappedRange.getFirst(), ImmutableList.of(mapped)));
-            hasAddedRanges = true;
-          }
-        }
-      }
-      if (!hasAddedRanges) {
-        narrowedRanges.add(new Pair<>(mappedRange.getFirst(), null));
-      }
-    }
-    return new RetraceFrameResult(
-        classResult,
-        narrowedRanges.isEmpty() ? noMappingRanges : narrowedRanges,
-        methodDefinition,
-        position,
-        retracer);
-  }
+  boolean isAmbiguous();
 
-  @Override
-  public Stream<Element> stream() {
-    return mappedRanges.stream()
-        .flatMap(
-            mappedRangePair -> {
-              RetraceClassResult.Element classElement = mappedRangePair.getFirst();
-              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
-              if (mappedRanges == null || mappedRanges.isEmpty()) {
-                return Stream.of(
-                    new Element(
-                        this,
-                        classElement,
-                        RetracedMethod.create(
-                            methodDefinition.substituteHolder(
-                                classElement.getRetracedClass().getClassReference()))));
-              }
-              return mappedRanges.stream()
-                  .map(
-                      mappedRange -> {
-                        MethodReference methodReference =
-                            RetraceUtils.methodReferenceFromMappedRange(
-                                mappedRange, classElement.getRetracedClass().getClassReference());
-                        return new Element(
-                            this, classElement, RetracedMethod.create(methodReference));
-                      });
-            });
-  }
+  @Keep
+  interface Element {
 
-  @Override
-  public RetraceMethodResult forEach(Consumer<Element> resultConsumer) {
-    stream().forEach(resultConsumer);
-    return this;
-  }
+    boolean isUnknown();
 
-  public static class Element implements RetraceClassMemberElement<RetracedMethod> {
+    RetracedMethod getRetracedMethod();
 
-    private final RetracedMethod methodReference;
-    private final RetraceMethodResult retraceMethodResult;
-    private final RetraceClassResult.Element classElement;
+    RetraceMethodResult getRetraceMethodResult();
 
-    private Element(
-        RetraceMethodResult retraceMethodResult,
-        RetraceClassResult.Element classElement,
-        RetracedMethod methodReference) {
-      this.classElement = classElement;
-      this.retraceMethodResult = retraceMethodResult;
-      this.methodReference = methodReference;
-    }
+    RetraceClassResult.Element getClassElement();
 
-    @Override
-    public boolean isUnknown() {
-      return methodReference.isUnknown();
-    }
-
-    @Override
-    public RetracedMethod getMember() {
-      return methodReference;
-    }
-
-    public RetraceMethodResult getRetraceMethodResult() {
-      return retraceMethodResult;
-    }
-
-    @Override
-    public RetraceClassResult.Element getClassElement() {
-      return classElement;
-    }
-
-    @Override
-    public void visitFrames(BiConsumer<RetracedMethod, Integer> consumer) {
-      consumer.accept(methodReference, 0);
-    }
-
-    @Override
-    public RetraceSourceFileResult retraceSourceFile(RetracedClassMember frame, String sourceFile) {
-      return RetraceUtils.getSourceFile(
-          classElement, methodReference.getHolderClass(), sourceFile, retraceMethodResult.retracer);
-    }
+    RetraceSourceFileResult retraceSourceFile(String sourceFile);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java
index e68e5c9..b2d4273 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java
@@ -7,21 +7,9 @@
 import com.android.tools.r8.Keep;
 
 @Keep
-public class RetraceSourceFileResult {
+public interface RetraceSourceFileResult {
 
-  private final String filename;
-  private final boolean synthesized;
+  boolean isSynthesized();
 
-  RetraceSourceFileResult(String filename, boolean synthesized) {
-    this.filename = filename;
-    this.synthesized = synthesized;
-  }
-
-  public boolean isSynthesized() {
-    return synthesized;
-  }
-
-  public String getFilename() {
-    return filename;
-  }
+  String getFilename();
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceStackTraceProxy.java b/src/main/java/com/android/tools/r8/retrace/RetraceStackTraceProxy.java
new file mode 100644
index 0000000..b69c237
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceStackTraceProxy.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2020, 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.retrace;
+
+import com.android.tools.r8.Keep;
+
+@Keep
+public interface RetraceStackTraceProxy<T extends StackTraceElementProxy<?>> {
+
+  boolean isAmbiguous();
+
+  boolean hasRetracedClass();
+
+  boolean hasRetracedMethod();
+
+  boolean hasSourceFile();
+
+  boolean hasLineNumber();
+
+  T getOriginalItem();
+
+  RetracedClass getRetracedClass();
+
+  RetracedMethod getRetracedMethod();
+
+  String getSourceFile();
+
+  int getLineNumber();
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
index d546d11..b9fa2d3 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
@@ -1,66 +1,26 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
 
-import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.retrace.RetraceTypeResult.Element;
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.retrace.internal.RetracedTypeImpl;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
-public class RetraceTypeResult extends Result<Element, RetraceTypeResult> {
+@Keep
+public interface RetraceTypeResult {
 
-  private final TypeReference obfuscatedType;
-  private final RetraceApi retracer;
+  Stream<Element> stream();
 
-  private RetraceTypeResult(TypeReference obfuscatedType, RetraceApi retracer) {
-    this.obfuscatedType = obfuscatedType;
-    this.retracer = retracer;
-  }
+  RetraceTypeResult forEach(Consumer<Element> resultConsumer);
 
-  static RetraceTypeResult create(TypeReference obfuscatedType, RetraceApi retracer) {
-    return new RetraceTypeResult(obfuscatedType, retracer);
-  }
+  boolean isAmbiguous();
 
-  @Override
-  public Stream<Element> stream() {
-    // Handle void and primitive types as single element results.
-    if (obfuscatedType == null || obfuscatedType.isPrimitive()) {
-      return Stream.of(new Element(RetracedType.create(obfuscatedType)));
-    }
-    if (obfuscatedType.isArray()) {
-      int dimensions = obfuscatedType.asArray().getDimensions();
-      return retracer.retrace(obfuscatedType.asArray().getBaseType()).stream()
-          .map(
-              baseElement ->
-                  new Element(RetracedType.create(baseElement.retracedType.toArray(dimensions))));
-    }
-    return retracer.retrace(obfuscatedType.asClass()).stream()
-        .map(classElement -> new Element(classElement.getRetracedClass().getRetracedType()));
-  }
+  @Keep
+  interface Element {
 
-  @Override
-  public boolean isAmbiguous() {
-    return false;
-  }
-
-  @Override
-  public RetraceTypeResult forEach(Consumer<Element> resultConsumer) {
-    stream().forEach(resultConsumer);
-    return this;
-  }
-
-  public static class Element {
-
-    private final RetracedType retracedType;
-
-    public Element(RetracedType retracedType) {
-      this.retracedType = retracedType;
-    }
-
-    public RetracedType getType() {
-      return retracedType;
-    }
+    RetracedTypeImpl getType();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetracedClass.java b/src/main/java/com/android/tools/r8/retrace/RetracedClass.java
index af064fc..e66931e 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetracedClass.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetracedClass.java
@@ -6,50 +6,16 @@
 
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.retrace.internal.RetracedTypeImpl;
 
 @Keep
-public final class RetracedClass {
+public interface RetracedClass {
 
-  private final ClassReference classReference;
+  String getTypeName();
 
-  private RetracedClass(ClassReference classReference) {
-    assert classReference != null;
-    this.classReference = classReference;
-  }
+  String getBinaryName();
 
-  public static RetracedClass create(ClassReference classReference) {
-    return new RetracedClass(classReference);
-  }
+  RetracedTypeImpl getRetracedType();
 
-  public String getTypeName() {
-    return classReference.getTypeName();
-  }
-
-  public String getBinaryName() {
-    return classReference.getBinaryName();
-  }
-
-  public RetracedType getRetracedType() {
-    return RetracedType.create(classReference);
-  }
-
-  ClassReference getClassReference() {
-    return classReference;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    return classReference.equals(((RetracedClass) o).classReference);
-  }
-
-  @Override
-  public int hashCode() {
-    return classReference.hashCode();
-  }
+  ClassReference getClassReference();
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetracedClassMember.java b/src/main/java/com/android/tools/r8/retrace/RetracedClassMember.java
index e05be47..10aa77c 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetracedClassMember.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetracedClassMember.java
@@ -4,7 +4,11 @@
 
 package com.android.tools.r8.retrace;
 
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.retrace.internal.RetracedClassImpl;
+
+@Keep
 public interface RetracedClassMember {
 
-  RetracedClass getHolderClass();
+  RetracedClassImpl getHolderClass();
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetracedField.java b/src/main/java/com/android/tools/r8/retrace/RetracedField.java
index 132d0c7..2af8c71 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetracedField.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetracedField.java
@@ -7,122 +7,23 @@
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.TypeReference;
-import java.util.Objects;
 
 @Keep
-public abstract class RetracedField implements RetracedClassMember {
+public interface RetracedField extends RetracedClassMember {
 
-  private RetracedField() {}
+  boolean isUnknown();
 
-  public boolean isUnknown() {
-    return true;
-  }
+  boolean isKnown();
 
-  public final boolean isKnown() {
-    return !isUnknown();
-  }
+  KnownRetracedField asKnown();
 
-  public KnownRetracedField asKnown() {
-    return null;
-  }
+  String getFieldName();
 
-  public abstract String getFieldName();
+  @Keep
+  interface KnownRetracedField extends RetracedField {
 
-  public static final class KnownRetracedField extends RetracedField {
+    TypeReference getFieldType();
 
-    private final FieldReference fieldReference;
-
-    private KnownRetracedField(FieldReference fieldReference) {
-      this.fieldReference = fieldReference;
-    }
-
-    @Override
-    public boolean isUnknown() {
-      return false;
-    }
-
-    @Override
-    public KnownRetracedField asKnown() {
-      return this;
-    }
-
-    @Override
-    public RetracedClass getHolderClass() {
-      return RetracedClass.create(fieldReference.getHolderClass());
-    }
-
-    @Override
-    public String getFieldName() {
-      return fieldReference.getFieldName();
-    }
-
-    public TypeReference getFieldType() {
-      return fieldReference.getFieldType();
-    }
-
-    public FieldReference getFieldReference() {
-      return fieldReference;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      KnownRetracedField that = (KnownRetracedField) o;
-      return fieldReference.equals(that.fieldReference);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(fieldReference);
-    }
-  }
-
-  public static final class UnknownRetracedField extends RetracedField {
-
-    private final FieldDefinition fieldDefinition;
-
-    private UnknownRetracedField(FieldDefinition fieldDefinition) {
-      this.fieldDefinition = fieldDefinition;
-    }
-
-    @Override
-    public RetracedClass getHolderClass() {
-      return RetracedClass.create(fieldDefinition.getHolderClass());
-    }
-
-    @Override
-    public String getFieldName() {
-      return fieldDefinition.getName();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      UnknownRetracedField that = (UnknownRetracedField) o;
-      return fieldDefinition.equals(that.fieldDefinition);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(fieldDefinition);
-    }
-  }
-
-  static RetracedField create(FieldReference fieldReference) {
-    return new KnownRetracedField(fieldReference);
-  }
-
-  static RetracedField create(FieldDefinition fieldDefinition) {
-    return new UnknownRetracedField(fieldDefinition);
+    FieldReference getFieldReference();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetracedMethod.java b/src/main/java/com/android/tools/r8/retrace/RetracedMethod.java
index 937ded1..bfc95e9 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetracedMethod.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetracedMethod.java
@@ -8,165 +8,31 @@
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.TypeReference;
 import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
 
 @Keep
-public abstract class RetracedMethod implements RetracedClassMember {
+public interface RetracedMethod extends RetracedClassMember {
 
-  private static final int NO_POSITION = -1;
+  boolean isUnknown();
 
-  private RetracedMethod() {}
+  boolean isKnown();
 
-  public boolean isUnknown() {
-    return true;
-  }
+  KnownRetracedMethod asKnown();
 
-  public final boolean isKnown() {
-    return !isUnknown();
-  }
+  String getMethodName();
 
-  public KnownRetracedMethod asKnown() {
-    return null;
-  }
+  boolean hasPosition();
 
-  public abstract String getMethodName();
+  int getOriginalPositionOrDefault(int defaultPosition);
 
-  public abstract boolean hasPosition();
+  @Keep
+  interface KnownRetracedMethod extends RetracedMethod {
 
-  public abstract int getOriginalPositionOrDefault(int defaultPosition);
+    boolean isVoid();
 
-  public static final class KnownRetracedMethod extends RetracedMethod {
+    TypeReference getReturnType();
 
-    private final MethodReference methodReference;
-    private final int position;
+    List<TypeReference> getFormalTypes();
 
-    private KnownRetracedMethod(MethodReference methodReference, int position) {
-      assert methodReference != null;
-      this.methodReference = methodReference;
-      this.position = position;
-    }
-
-    @Override
-    public boolean isUnknown() {
-      return false;
-    }
-
-    public boolean isVoid() {
-      return methodReference.getReturnType() == null;
-    }
-
-    @Override
-    public KnownRetracedMethod asKnown() {
-      return this;
-    }
-
-    @Override
-    public RetracedClass getHolderClass() {
-      return RetracedClass.create(methodReference.getHolderClass());
-    }
-
-    @Override
-    public String getMethodName() {
-      return methodReference.getMethodName();
-    }
-
-    @Override
-    public boolean hasPosition() {
-      return position != NO_POSITION;
-    }
-
-    @Override
-    public int getOriginalPositionOrDefault(int defaultPosition) {
-      return hasPosition() ? position : defaultPosition;
-    }
-
-    public TypeReference getReturnType() {
-      assert !isVoid();
-      return methodReference.getReturnType();
-    }
-
-    public List<TypeReference> getFormalTypes() {
-      return methodReference.getFormalTypes();
-    }
-
-    public MethodReference getMethodReference() {
-      return methodReference;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      KnownRetracedMethod that = (KnownRetracedMethod) o;
-      return position == that.position && methodReference.equals(that.methodReference);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(methodReference, position);
-    }
-  }
-
-  public static final class UnknownRetracedMethod extends RetracedMethod {
-
-    private final MethodDefinition methodDefinition;
-    private final int position;
-
-    private UnknownRetracedMethod(MethodDefinition methodDefinition, int position) {
-      this.methodDefinition = methodDefinition;
-      this.position = position;
-    }
-
-    @Override
-    public RetracedClass getHolderClass() {
-      return RetracedClass.create(methodDefinition.getHolderClass());
-    }
-
-    @Override
-    public String getMethodName() {
-      return methodDefinition.getName();
-    }
-
-    @Override
-    public boolean hasPosition() {
-      return position != NO_POSITION;
-    }
-
-    @Override
-    public int getOriginalPositionOrDefault(int defaultPosition) {
-      return hasPosition() ? position : defaultPosition;
-    }
-
-    public Optional<MethodReference> getMethodReference() {
-      if (!methodDefinition.isFullMethodDefinition()) {
-        return Optional.empty();
-      }
-      return Optional.of(methodDefinition.asFullMethodDefinition().getMethodReference());
-    }
-  }
-
-  static RetracedMethod create(MethodDefinition methodDefinition) {
-    return create(methodDefinition, NO_POSITION);
-  }
-
-  static RetracedMethod create(MethodDefinition methodDefinition, int position) {
-    if (methodDefinition.isFullMethodDefinition()) {
-      return new KnownRetracedMethod(
-          methodDefinition.asFullMethodDefinition().getMethodReference(), position);
-    }
-    return new UnknownRetracedMethod(methodDefinition, position);
-  }
-
-  static RetracedMethod create(MethodReference methodReference) {
-    return create(methodReference, NO_POSITION);
-  }
-
-  static RetracedMethod create(MethodReference methodReference, int position) {
-    return new KnownRetracedMethod(methodReference, position);
+    MethodReference getMethodReference();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetracedType.java b/src/main/java/com/android/tools/r8/retrace/RetracedType.java
index 016c8df..7d5baa1 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetracedType.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetracedType.java
@@ -5,53 +5,16 @@
 package com.android.tools.r8.retrace;
 
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
-import java.util.Objects;
 
 @Keep
-public final class RetracedType {
+public interface RetracedType {
 
-  private final TypeReference typeReference;
+  boolean isVoid();
 
-  private RetracedType(TypeReference typeReference) {
-    this.typeReference = typeReference;
-  }
+  TypeReference toArray(int dimensions);
 
-  static RetracedType create(TypeReference typeReference) {
-    return new RetracedType(typeReference);
-  }
+  String getTypeName();
 
-  public boolean isVoid() {
-    return typeReference == null;
-  }
-
-  public TypeReference toArray(int dimensions) {
-    return Reference.array(typeReference, dimensions);
-  }
-
-  public String getTypeName() {
-    assert !isVoid();
-    return typeReference.getTypeName();
-  }
-
-  public TypeReference getTypeReference() {
-    return typeReference;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    return typeReference.equals(((RetracedType) o).typeReference);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(typeReference);
-  }
+  TypeReference getTypeReference();
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/Retracer.java b/src/main/java/com/android/tools/r8/retrace/Retracer.java
index 279253c..57b7607 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retracer.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retracer.java
@@ -4,66 +4,23 @@
 
 package com.android.tools.r8.retrace;
 
-import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
 
-/** A default implementation for the retrace api using the ClassNameMapper defined in R8. */
+/** This is the main api interface for retrace. */
 @Keep
-public class Retracer implements RetraceApi {
+public interface Retracer {
 
-  private final ClassNameMapper classNameMapper;
+  RetraceClassResult retraceClass(ClassReference classReference);
 
-  private Retracer(ClassNameMapper classNameMapper) {
-    this.classNameMapper = classNameMapper;
-    assert classNameMapper != null;
-  }
+  RetraceMethodResult retraceMethod(MethodReference methodReference);
 
-  public static RetraceApi create(
-      ProguardMapProducer proguardMapProducer, DiagnosticsHandler diagnosticsHandler) {
-    if (proguardMapProducer instanceof DirectClassNameMapperProguardMapProducer) {
-      return new Retracer(
-          ((DirectClassNameMapperProguardMapProducer) proguardMapProducer).getClassNameMapper());
-    }
-    try {
-      ClassNameMapper classNameMapper =
-          ClassNameMapper.mapperFromString(proguardMapProducer.get(), diagnosticsHandler);
-      return new Retracer(classNameMapper);
-    } catch (Throwable throwable) {
-      throw new InvalidMappingFileException(throwable);
-    }
-  }
+  RetraceFrameResult retraceFrame(MethodReference methodReference, int position);
 
-  @Override
-  public RetraceMethodResult retrace(MethodReference methodReference) {
-    return retrace(methodReference.getHolderClass()).lookupMethod(methodReference.getMethodName());
-  }
+  RetraceFieldResult retraceField(FieldReference fieldReference);
 
-  @Override
-  public RetraceFieldResult retrace(FieldReference fieldReference) {
-    return retrace(fieldReference.getHolderClass()).lookupField(fieldReference.getFieldName());
-  }
-
-  @Override
-  public RetraceFrameResult retrace(MethodReference methodReference, int position) {
-    return retrace(methodReference.getHolderClass())
-        .lookupMethod(methodReference.getMethodName())
-        .narrowByPosition(position);
-  }
-
-  @Override
-  public RetraceClassResult retrace(ClassReference classReference) {
-    return RetraceClassResult.create(
-        classReference, classNameMapper.getClassNaming(classReference.getTypeName()), this);
-  }
-
-  @Override
-  public RetraceTypeResult retrace(TypeReference typeReference) {
-    return RetraceTypeResult.create(typeReference, this);
-  }
+  RetraceTypeResult retraceType(TypeReference typeReference);
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/StackTraceElementProxyRetracer.java b/src/main/java/com/android/tools/r8/retrace/StackTraceElementProxyRetracer.java
index 042b1f8..17d9005 100644
--- a/src/main/java/com/android/tools/r8/retrace/StackTraceElementProxyRetracer.java
+++ b/src/main/java/com/android/tools/r8/retrace/StackTraceElementProxyRetracer.java
@@ -5,191 +5,11 @@
 package com.android.tools.r8.retrace;
 
 import com.android.tools.r8.Keep;
-import com.android.tools.r8.references.Reference;
-import java.util.ArrayList;
-import java.util.List;
+import com.android.tools.r8.retrace.internal.StackTraceElementProxyRetracerImpl.RetraceStackTraceProxyImpl;
 import java.util.stream.Stream;
 
 @Keep
-public class StackTraceElementProxyRetracer<T extends StackTraceElementProxy<?>> {
+public interface StackTraceElementProxyRetracer<T extends StackTraceElementProxy<?>> {
 
-  private final RetraceApi retracer;
-
-  public StackTraceElementProxyRetracer(RetraceApi retracer) {
-    this.retracer = retracer;
-  }
-
-  public Stream<RetraceStackTraceProxy<T>> retrace(T element) {
-    if (!element.hasClassName()) {
-      return Stream.of(RetraceStackTraceProxy.builder(element).build());
-    }
-    RetraceClassResult classResult =
-        retracer.retrace(Reference.classFromTypeName(element.className()));
-    List<RetraceStackTraceProxy<T>> retracedProxies = new ArrayList<>();
-    if (!element.hasMethodName()) {
-      classResult.forEach(
-          classElement -> {
-            RetraceStackTraceProxy.Builder<T> proxy =
-                RetraceStackTraceProxy.builder(element)
-                    .setRetracedClassElement(classElement.getRetracedClass())
-                    .setAmbiguous(classResult.isAmbiguous());
-            if (element.hasFileName()) {
-              proxy.setSourceFile(classElement.retraceSourceFile(element.fileName()).getFilename());
-            }
-            retracedProxies.add(proxy.build());
-          });
-    } else {
-      RetraceMethodResult retraceMethodResult = classResult.lookupMethod(element.methodName());
-      Result<? extends RetraceClassMemberElement<RetracedMethod>, ?> methodResult;
-      if (element.hasLineNumber()) {
-        methodResult = retraceMethodResult.narrowByPosition(element.lineNumber());
-      } else {
-        methodResult = retraceMethodResult;
-      }
-      methodResult.forEach(
-          methodElement -> {
-            methodElement.visitFrames(
-                (frame, index) -> {
-                  RetraceStackTraceProxy.Builder<T> proxy =
-                      RetraceStackTraceProxy.builder(element)
-                          .setRetracedClassElement(frame.getHolderClass())
-                          .setRetracedMethodElement(frame)
-                          .setAmbiguous(methodResult.isAmbiguous() && index == 0);
-                  if (element.hasLineNumber()) {
-                    proxy.setLineNumber(frame.getOriginalPositionOrDefault(element.lineNumber()));
-                  }
-                  if (element.hasFileName()) {
-                    proxy.setSourceFile(
-                        methodElement.retraceSourceFile(frame, element.fileName()).getFilename());
-                  }
-                  retracedProxies.add(proxy.build());
-                });
-          });
-    }
-    return retracedProxies.stream();
-  }
-
-  @Keep
-  public static class RetraceStackTraceProxy<T extends StackTraceElementProxy<?>> {
-
-    private final T originalItem;
-    private final RetracedClass retracedClass;
-    private final RetracedMethod retracedMethod;
-    private final String sourceFile;
-    private final int lineNumber;
-    private final boolean isAmbiguous;
-
-    private RetraceStackTraceProxy(
-        T originalItem,
-        RetracedClass retracedClass,
-        RetracedMethod retracedMethod,
-        String sourceFile,
-        int lineNumber,
-        boolean isAmbiguous) {
-      assert originalItem != null;
-      this.originalItem = originalItem;
-      this.retracedClass = retracedClass;
-      this.retracedMethod = retracedMethod;
-      this.sourceFile = sourceFile;
-      this.lineNumber = lineNumber;
-      this.isAmbiguous = isAmbiguous;
-    }
-
-    public boolean isAmbiguous() {
-      return isAmbiguous;
-    }
-
-    public boolean hasRetracedClass() {
-      return retracedClass != null;
-    }
-
-    public boolean hasRetracedMethod() {
-      return retracedMethod != null;
-    }
-
-    public boolean hasSourceFile() {
-      return sourceFile != null;
-    }
-
-    public boolean hasLineNumber() {
-      return lineNumber != -1;
-    }
-
-    public T getOriginalItem() {
-      return originalItem;
-    }
-
-    public RetracedClass getRetracedClass() {
-      return retracedClass;
-    }
-
-    public RetracedMethod getRetracedMethod() {
-      return retracedMethod;
-    }
-
-    public String getSourceFile() {
-      return sourceFile;
-    }
-
-    private static <T extends StackTraceElementProxy<?>> Builder<T> builder(T originalElement) {
-      return new Builder<>(originalElement);
-    }
-
-    public int getLineNumber() {
-      return lineNumber;
-    }
-
-    private static class Builder<T extends StackTraceElementProxy<?>> {
-
-      private final T originalElement;
-      private RetracedClass classContext;
-      private RetracedMethod methodContext;
-      private String sourceFile;
-      private int lineNumber = -1;
-      private boolean isAmbiguous;
-
-      private Builder(T originalElement) {
-        this.originalElement = originalElement;
-      }
-
-      private Builder<T> setRetracedClassElement(RetracedClass retracedClass) {
-        this.classContext = retracedClass;
-        return this;
-      }
-
-      private Builder<T> setRetracedMethodElement(RetracedMethod methodElement) {
-        this.methodContext = methodElement;
-        return this;
-      }
-
-      private Builder<T> setSourceFile(String sourceFile) {
-        this.sourceFile = sourceFile;
-        return this;
-      }
-
-      private Builder<T> setLineNumber(int lineNumber) {
-        this.lineNumber = lineNumber;
-        return this;
-      }
-
-      private Builder<T> setAmbiguous(boolean ambiguous) {
-        this.isAmbiguous = ambiguous;
-        return this;
-      }
-
-      private RetraceStackTraceProxy<T> build() {
-        RetracedClass retracedClass = classContext;
-        if (methodContext != null) {
-          retracedClass = methodContext.getHolderClass();
-        }
-        return new RetraceStackTraceProxy<>(
-            originalElement,
-            retracedClass,
-            methodContext,
-            sourceFile != null ? sourceFile : null,
-            lineNumber,
-            isAmbiguous);
-      }
-    }
-  }
+  Stream<RetraceStackTraceProxyImpl<T>> retrace(T element);
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/AmbiguousComparator.java b/src/main/java/com/android/tools/r8/retrace/internal/AmbiguousComparator.java
similarity index 96%
rename from src/main/java/com/android/tools/r8/retrace/AmbiguousComparator.java
rename to src/main/java/com/android/tools/r8/retrace/internal/AmbiguousComparator.java
index 35266e7..d3c5a01 100644
--- a/src/main/java/com/android/tools/r8/retrace/AmbiguousComparator.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/AmbiguousComparator.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import java.util.Comparator;
 import java.util.function.BiFunction;
diff --git a/src/main/java/com/android/tools/r8/retrace/Definition.java b/src/main/java/com/android/tools/r8/retrace/internal/Definition.java
similarity index 88%
rename from src/main/java/com/android/tools/r8/retrace/Definition.java
rename to src/main/java/com/android/tools/r8/retrace/internal/Definition.java
index f955ac0..65a1736 100644
--- a/src/main/java/com/android/tools/r8/retrace/Definition.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/Definition.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.references.ClassReference;
 
diff --git a/src/main/java/com/android/tools/r8/retrace/DirectClassNameMapperProguardMapProducer.java b/src/main/java/com/android/tools/r8/retrace/internal/DirectClassNameMapperProguardMapProducer.java
similarity index 92%
rename from src/main/java/com/android/tools/r8/retrace/DirectClassNameMapperProguardMapProducer.java
rename to src/main/java/com/android/tools/r8/retrace/internal/DirectClassNameMapperProguardMapProducer.java
index 8efe05a..07bf237 100644
--- a/src/main/java/com/android/tools/r8/retrace/DirectClassNameMapperProguardMapProducer.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/DirectClassNameMapperProguardMapProducer.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
diff --git a/src/main/java/com/android/tools/r8/retrace/FieldDefinition.java b/src/main/java/com/android/tools/r8/retrace/internal/FieldDefinition.java
similarity index 98%
rename from src/main/java/com/android/tools/r8/retrace/FieldDefinition.java
rename to src/main/java/com/android/tools/r8/retrace/internal/FieldDefinition.java
index 3dcf1c9..4a3b93c 100644
--- a/src/main/java/com/android/tools/r8/retrace/FieldDefinition.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/FieldDefinition.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
diff --git a/src/main/java/com/android/tools/r8/retrace/MethodDefinition.java b/src/main/java/com/android/tools/r8/retrace/internal/MethodDefinition.java
similarity index 98%
rename from src/main/java/com/android/tools/r8/retrace/MethodDefinition.java
rename to src/main/java/com/android/tools/r8/retrace/internal/MethodDefinition.java
index 8641f13..b1e23f5 100644
--- a/src/main/java/com/android/tools/r8/retrace/MethodDefinition.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/MethodDefinition.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
diff --git a/src/main/java/com/android/tools/r8/retrace/PlainStackTraceVisitor.java b/src/main/java/com/android/tools/r8/retrace/internal/PlainStackTraceVisitor.java
similarity index 96%
rename from src/main/java/com/android/tools/r8/retrace/PlainStackTraceVisitor.java
rename to src/main/java/com/android/tools/r8/retrace/internal/PlainStackTraceVisitor.java
index 1234b4d..0aac05f 100644
--- a/src/main/java/com/android/tools/r8/retrace/PlainStackTraceVisitor.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/PlainStackTraceVisitor.java
@@ -2,12 +2,12 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import static com.google.common.base.Predicates.not;
 
 import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.retrace.StackTraceElementStringProxy.StackTraceElementStringProxyBuilder;
+import com.android.tools.r8.retrace.internal.StackTraceElementStringProxy.StackTraceElementStringProxyBuilder;
 import com.android.tools.r8.utils.DescriptorUtils;
 import java.util.List;
 import java.util.function.Consumer;
@@ -19,7 +19,7 @@
   private final List<String> stackTrace;
   private final DiagnosticsHandler diagnosticsHandler;
 
-  PlainStackTraceVisitor(List<String> stackTrace, DiagnosticsHandler diagnosticsHandler) {
+  public PlainStackTraceVisitor(List<String> stackTrace, DiagnosticsHandler diagnosticsHandler) {
     this.stackTrace = stackTrace;
     this.diagnosticsHandler = diagnosticsHandler;
   }
@@ -209,7 +209,7 @@
   private StackTraceElementStringProxy parseLine(int lineNumber, String line) {
     if (line == null) {
       diagnosticsHandler.error(RetraceInvalidStackTraceLineDiagnostics.createNull(lineNumber));
-      throw new Retrace.RetraceAbortException();
+      throw new RetraceAbortException();
     }
     // Most lines are 'at lines' so attempt to parse it first.
     StackTraceElementStringProxy parsedLine = AtLine.tryParse(line);
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceAbortException.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceAbortException.java
new file mode 100644
index 0000000..60eee2f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceAbortException.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+public class RetraceAbortException extends RuntimeException {}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
new file mode 100644
index 0000000..45b7fdd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
@@ -0,0 +1,346 @@
+// Copyright (c) 2019, 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.retrace.internal;
+
+import static com.android.tools.r8.naming.MemberNaming.NoSignature.NO_SIGNATURE;
+import static com.android.tools.r8.retrace.internal.RetraceUtils.synthesizeFileName;
+
+import com.android.tools.r8.naming.ClassNamingForNameMapper;
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
+import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetraceClassResult;
+import com.android.tools.r8.retrace.RetraceFrameResult;
+import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public class RetraceClassResultImpl implements RetraceClassResult {
+
+  private final ClassReference obfuscatedReference;
+  private final ClassNamingForNameMapper mapper;
+  private final RetracerImpl retracer;
+
+  private RetraceClassResultImpl(
+      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetracerImpl retracer) {
+    this.obfuscatedReference = obfuscatedReference;
+    this.mapper = mapper;
+    this.retracer = retracer;
+  }
+
+  static RetraceClassResultImpl create(
+      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetracerImpl retracer) {
+    return new RetraceClassResultImpl(obfuscatedReference, mapper, retracer);
+  }
+
+  @Override
+  public RetraceFieldResultImpl lookupField(String fieldName) {
+    return lookupField(FieldDefinition.create(obfuscatedReference, fieldName));
+  }
+
+  @Override
+  public RetraceFieldResultImpl lookupField(String fieldName, TypeReference fieldType) {
+    return lookupField(
+        FieldDefinition.create(Reference.field(obfuscatedReference, fieldName, fieldType)));
+  }
+
+  @Override
+  public RetraceMethodResultImpl lookupMethod(String methodName) {
+    return lookupMethod(MethodDefinition.create(obfuscatedReference, methodName));
+  }
+
+  @Override
+  public RetraceMethodResultImpl lookupMethod(
+      String methodName, List<TypeReference> formalTypes, TypeReference returnType) {
+    return lookupMethod(
+        MethodDefinition.create(
+            Reference.method(obfuscatedReference, methodName, formalTypes, returnType)));
+  }
+
+  private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
+    return lookup(
+        fieldDefinition,
+        (mapper, name) -> {
+          List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
+          if (memberNamings == null || memberNamings.isEmpty()) {
+            return null;
+          }
+          return memberNamings;
+        },
+        RetraceFieldResultImpl::new);
+  }
+
+  private RetraceMethodResultImpl lookupMethod(MethodDefinition methodDefinition) {
+    return lookup(
+        methodDefinition,
+        (mapper, name) -> {
+          MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
+          if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
+            return null;
+          }
+          return mappedRanges.getMappedRanges();
+        },
+        RetraceMethodResultImpl::new);
+  }
+
+  private <T, R, D extends Definition> R lookup(
+      D definition,
+      BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
+      ResultConstructor<T, R, D> constructor) {
+    List<Pair<ElementImpl, T>> mappings = new ArrayList<>();
+    internalStream()
+        .forEach(
+            element -> {
+              if (mapper != null) {
+                assert element.mapper != null;
+                T mappedElements = lookupFunction.apply(element.mapper, definition.getName());
+                if (mappedElements != null) {
+                  mappings.add(new Pair<>(element, mappedElements));
+                  return;
+                }
+              }
+              mappings.add(new Pair<>(element, null));
+            });
+    return constructor.create(this, mappings, definition, retracer);
+  }
+
+  @Override
+  public RetraceFrameResultImpl lookupFrame(String methodName) {
+    return lookupFrame(MethodDefinition.create(obfuscatedReference, methodName), -1);
+  }
+
+  @Override
+  public RetraceFrameResultImpl lookupFrame(String methodName, int position) {
+    return lookupFrame(MethodDefinition.create(obfuscatedReference, methodName), position);
+  }
+
+  @Override
+  public RetraceFrameResultImpl lookupFrame(
+      String methodName, int position, List<TypeReference> formalTypes, TypeReference returnType) {
+    return lookupFrame(
+        MethodDefinition.create(
+            Reference.method(obfuscatedReference, methodName, formalTypes, returnType)),
+        position);
+  }
+
+  private RetraceFrameResultImpl lookupFrame(MethodDefinition definition, int position) {
+    List<Pair<ElementImpl, List<MappedRange>>> mappings = new ArrayList<>();
+    internalStream()
+        .forEach(
+            element ->
+                mappings.add(
+                    new Pair<>(element, getMappedRangesForFrame(element, definition, position))));
+    return new RetraceFrameResultImpl(this, mappings, definition, position, retracer);
+  }
+
+  private List<MappedRange> getMappedRangesForFrame(
+      ElementImpl element, MethodDefinition definition, int position) {
+    if (mapper == null) {
+      return null;
+    }
+    assert element.mapper != null;
+    MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(definition.getName());
+    if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
+      return null;
+    }
+    if (position <= 0) {
+      return mappedRanges.getMappedRanges();
+    }
+    List<MappedRange> mappedRangesForPosition = mappedRanges.allRangesForLine(position, false);
+    return mappedRangesForPosition.isEmpty()
+        ? mappedRanges.getMappedRanges()
+        : mappedRangesForPosition;
+  }
+
+  boolean hasRetraceResult() {
+    return mapper != null;
+  }
+
+  @Override
+  public Stream<Element> stream() {
+    return Stream.of(createElement());
+  }
+
+  private Stream<ElementImpl> internalStream() {
+    return Stream.of(createElement());
+  }
+
+  private ElementImpl createElement() {
+    return new ElementImpl(
+        this,
+        RetracedClassImpl.create(
+            mapper == null
+                ? obfuscatedReference
+                : Reference.classFromTypeName(mapper.originalName)),
+        mapper);
+  }
+
+  @Override
+  public RetraceClassResultImpl forEach(Consumer<Element> resultConsumer) {
+    stream().forEach(resultConsumer);
+    return this;
+  }
+
+  private interface ResultConstructor<T, R, D> {
+    R create(
+        RetraceClassResultImpl classResult,
+        List<Pair<ElementImpl, T>> mappings,
+        D definition,
+        RetracerImpl retracer);
+  }
+
+  @Override
+  public boolean isAmbiguous() {
+    // Currently we have no way of producing ambiguous class results.
+    return false;
+  }
+
+  public static class ElementImpl implements Element {
+
+    private final RetraceClassResultImpl classResult;
+    private final RetracedClassImpl classReference;
+    private final ClassNamingForNameMapper mapper;
+
+    public ElementImpl(
+        RetraceClassResultImpl classResult,
+        RetracedClassImpl classReference,
+        ClassNamingForNameMapper mapper) {
+      this.classResult = classResult;
+      this.classReference = classReference;
+      this.mapper = mapper;
+    }
+
+    @Override
+    public RetracedClassImpl getRetracedClass() {
+      return classReference;
+    }
+
+    @Override
+    public RetraceClassResultImpl getRetraceClassResult() {
+      return classResult;
+    }
+
+    @Override
+    public RetraceSourceFileResultImpl retraceSourceFile(String sourceFile) {
+      if (mapper != null && mapper.getAdditionalMappings().size() > 0) {
+        List<MappingInformation> mappingInformations =
+            mapper.getAdditionalMappings().get(NO_SIGNATURE);
+        if (mappingInformations != null) {
+          for (MappingInformation mappingInformation : mappingInformations) {
+            if (mappingInformation.isFileNameInformation()) {
+              return new RetraceSourceFileResultImpl(
+                  mappingInformation.asFileNameInformation().getFileName(), false);
+            }
+          }
+        }
+      }
+      return new RetraceSourceFileResultImpl(
+          synthesizeFileName(
+              classReference.getTypeName(),
+              classResult.obfuscatedReference.getTypeName(),
+              sourceFile,
+              mapper != null),
+          true);
+    }
+
+    @Override
+    public RetraceFieldResultImpl lookupField(String fieldName) {
+      return lookupField(FieldDefinition.create(classReference.getClassReference(), fieldName));
+    }
+
+    private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
+      return lookup(
+          fieldDefinition,
+          (mapper, name) -> {
+            List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
+            if (memberNamings == null || memberNamings.isEmpty()) {
+              return null;
+            }
+            return memberNamings;
+          },
+          RetraceFieldResultImpl::new);
+    }
+
+    @Override
+    public RetraceMethodResultImpl lookupMethod(String methodName) {
+      return lookupMethod(MethodDefinition.create(classReference.getClassReference(), methodName));
+    }
+
+    private RetraceMethodResultImpl lookupMethod(MethodDefinition methodDefinition) {
+      return lookup(
+          methodDefinition,
+          (mapper, name) -> {
+            MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
+            if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
+              return null;
+            }
+            return mappedRanges.getMappedRanges();
+          },
+          RetraceMethodResultImpl::new);
+    }
+
+    private <T, R, D extends Definition> R lookup(
+        D definition,
+        BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
+        ResultConstructor<T, R, D> constructor) {
+      List<Pair<ElementImpl, T>> mappings = ImmutableList.of();
+      if (mapper != null) {
+        T result = lookupFunction.apply(mapper, definition.getName());
+        if (result != null) {
+          mappings = ImmutableList.of(new Pair<>(this, result));
+        }
+      }
+      if (mappings.isEmpty()) {
+        mappings = ImmutableList.of(new Pair<>(this, null));
+      }
+      return constructor.create(classResult, mappings, definition, classResult.retracer);
+    }
+
+    @Override
+    public RetraceFrameResultImpl lookupFrame(String methodName) {
+      return lookupFrame(methodName, -1);
+    }
+
+    @Override
+    public RetraceFrameResultImpl lookupFrame(String methodName, int position) {
+      return lookupFrame(
+          MethodDefinition.create(classReference.getClassReference(), methodName), position);
+    }
+
+    @Override
+    public RetraceFrameResult lookupFrame(
+        String methodName,
+        int position,
+        List<TypeReference> formalTypes,
+        TypeReference returnType) {
+      return lookupFrame(
+          MethodDefinition.create(
+              Reference.method(
+                  classReference.getClassReference(), methodName, formalTypes, returnType)),
+          position);
+    }
+
+    private RetraceFrameResultImpl lookupFrame(MethodDefinition definition, int position) {
+      MethodDefinition methodDefinition =
+          MethodDefinition.create(classReference.getClassReference(), definition.getName());
+      return new RetraceFrameResultImpl(
+          classResult,
+          ImmutableList.of(
+              new Pair<>(
+                  this, classResult.getMappedRangesForFrame(this, methodDefinition, position))),
+          methodDefinition,
+          position,
+          classResult.retracer);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceCommandLineResult.java
similarity index 67%
rename from src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java
rename to src/main/java/com/android/tools/r8/retrace/internal/RetraceCommandLineResult.java
index 00f1857..8686ede 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceCommandLineResult.java
@@ -1,8 +1,8 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import java.util.List;
 
@@ -10,7 +10,7 @@
 
   private final List<String> nodes;
 
-  RetraceCommandLineResult(List<String> nodes) {
+  public RetraceCommandLineResult(List<String> nodes) {
     this.nodes = nodes;
   }
 
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
new file mode 100644
index 0000000..066b979
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
@@ -0,0 +1,135 @@
+// Copyright (c) 2019, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.naming.MemberNaming.FieldSignature;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.retrace.RetraceFieldResult;
+import com.android.tools.r8.retrace.Retracer;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.Pair;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+@Keep
+public class RetraceFieldResultImpl implements RetraceFieldResult {
+
+  private final RetraceClassResultImpl classResult;
+  private final List<Pair<RetraceClassResultImpl.ElementImpl, List<MemberNaming>>> memberNamings;
+  private final FieldDefinition fieldDefinition;
+  private final Retracer retracer;
+
+  RetraceFieldResultImpl(
+      RetraceClassResultImpl classResult,
+      List<Pair<RetraceClassResultImpl.ElementImpl, List<MemberNaming>>> memberNamings,
+      FieldDefinition fieldDefinition,
+      Retracer retracer) {
+    this.classResult = classResult;
+    this.memberNamings = memberNamings;
+    this.fieldDefinition = fieldDefinition;
+    this.retracer = retracer;
+    assert classResult != null;
+    assert !memberNamings.isEmpty();
+  }
+
+  @Override
+  public Stream<Element> stream() {
+    return memberNamings.stream()
+        .flatMap(
+            mappedNamePair -> {
+              RetraceClassResultImpl.ElementImpl classElement = mappedNamePair.getFirst();
+              List<MemberNaming> memberNamings = mappedNamePair.getSecond();
+              if (memberNamings == null) {
+                return Stream.of(
+                    new ElementImpl(
+                        this,
+                        classElement,
+                        RetracedFieldImpl.create(
+                            fieldDefinition.substituteHolder(
+                                classElement.getRetracedClass().getClassReference()))));
+              }
+              return memberNamings.stream()
+                  .map(
+                      memberNaming -> {
+                        FieldSignature fieldSignature =
+                            memberNaming.getOriginalSignature().asFieldSignature();
+                        RetracedClassImpl holder =
+                            fieldSignature.isQualified()
+                                ? RetracedClassImpl.create(
+                                    Reference.classFromDescriptor(
+                                        DescriptorUtils.javaTypeToDescriptor(
+                                            fieldSignature.toHolderFromQualified())))
+                                : classElement.getRetracedClass();
+                        return new ElementImpl(
+                            this,
+                            classElement,
+                            RetracedFieldImpl.create(
+                                Reference.field(
+                                    holder.getClassReference(),
+                                    fieldSignature.isQualified()
+                                        ? fieldSignature.toUnqualifiedName()
+                                        : fieldSignature.name,
+                                    Reference.typeFromTypeName(fieldSignature.type))));
+                      });
+            });
+  }
+
+  @Override
+  public RetraceFieldResultImpl forEach(Consumer<Element> resultConsumer) {
+    stream().forEach(resultConsumer);
+    return this;
+  }
+
+  @Override
+  public boolean isAmbiguous() {
+    if (memberNamings.size() > 1) {
+      return true;
+    }
+    List<MemberNaming> mappings = memberNamings.get(0).getSecond();
+    if (mappings == null) {
+      return false;
+    }
+    return mappings.size() > 1;
+  }
+
+  public static class ElementImpl implements RetraceFieldResult.Element {
+
+    private final RetracedFieldImpl fieldReference;
+    private final RetraceFieldResultImpl retraceFieldResult;
+    private final RetraceClassResultImpl.ElementImpl classElement;
+
+    private ElementImpl(
+        RetraceFieldResultImpl retraceFieldResult,
+        RetraceClassResultImpl.ElementImpl classElement,
+        RetracedFieldImpl fieldReference) {
+      this.classElement = classElement;
+      this.fieldReference = fieldReference;
+      this.retraceFieldResult = retraceFieldResult;
+    }
+
+    @Override
+    public boolean isUnknown() {
+      return fieldReference.isUnknown();
+    }
+
+    @Override
+    public RetracedFieldImpl getField() {
+      return fieldReference;
+    }
+
+    @Override
+    public RetraceFieldResultImpl getRetraceFieldResult() {
+      return retraceFieldResult;
+    }
+
+    @Override
+    public RetraceClassResultImpl.ElementImpl getClassElement() {
+      return classElement;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
new file mode 100644
index 0000000..24c5a8e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
@@ -0,0 +1,203 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import static com.android.tools.r8.retrace.internal.RetraceUtils.methodReferenceFromMappedRange;
+
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.Range;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.retrace.RetraceFrameResult;
+import com.android.tools.r8.retrace.RetraceSourceFileResult;
+import com.android.tools.r8.retrace.RetracedClassMember;
+import com.android.tools.r8.retrace.RetracedMethod;
+import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public class RetraceFrameResultImpl implements RetraceFrameResult {
+
+  private final RetraceClassResultImpl classResult;
+  private final MethodDefinition methodDefinition;
+  private final int obfuscatedPosition;
+  private final List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> mappedRanges;
+  private final RetracerImpl retracer;
+
+  public RetraceFrameResultImpl(
+      RetraceClassResultImpl classResult,
+      List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> mappedRanges,
+      MethodDefinition methodDefinition,
+      int obfuscatedPosition,
+      RetracerImpl retracer) {
+    this.classResult = classResult;
+    this.methodDefinition = methodDefinition;
+    this.obfuscatedPosition = obfuscatedPosition;
+    this.mappedRanges = mappedRanges;
+    this.retracer = retracer;
+  }
+
+  @Override
+  public boolean isAmbiguous() {
+    if (mappedRanges.size() > 1) {
+      return true;
+    }
+    List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
+    if (methodRanges == null || methodRanges.isEmpty()) {
+      return false;
+    }
+    MappedRange lastRange = methodRanges.get(0);
+    for (MappedRange mappedRange : methodRanges) {
+      if (mappedRange != lastRange
+          && (mappedRange.minifiedRange == null
+              || !mappedRange.minifiedRange.equals(lastRange.minifiedRange))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public Stream<Element> stream() {
+    return mappedRanges.stream()
+        .flatMap(
+            mappedRangePair -> {
+              RetraceClassResultImpl.ElementImpl classElement = mappedRangePair.getFirst();
+              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
+              if (mappedRanges == null || mappedRanges.isEmpty()) {
+                return Stream.of(
+                    new ElementImpl(
+                        this,
+                        classElement,
+                        RetracedMethodImpl.create(
+                            methodDefinition.substituteHolder(
+                                classElement.getRetracedClass().getClassReference())),
+                        ImmutableList.of(),
+                        obfuscatedPosition));
+              }
+              // Iterate over mapped ranges that may have different positions than specified.
+              List<ElementImpl> ambiguousFrames = new ArrayList<>();
+              Range minifiedRange = mappedRanges.get(0).minifiedRange;
+              List<MappedRange> mappedRangesForElement = Lists.newArrayList(mappedRanges.get(0));
+              for (int i = 1; i < mappedRanges.size(); i++) {
+                MappedRange mappedRange = mappedRanges.get(i);
+                if (minifiedRange == null || !minifiedRange.equals(mappedRange.minifiedRange)) {
+                  // This is a new frame
+                  ambiguousFrames.add(
+                      elementFromMappedRanges(mappedRangesForElement, classElement));
+                  mappedRangesForElement = new ArrayList<>();
+                }
+                mappedRangesForElement.add(mappedRange);
+              }
+              ambiguousFrames.add(elementFromMappedRanges(mappedRangesForElement, classElement));
+              return ambiguousFrames.stream();
+            });
+  }
+
+  private ElementImpl elementFromMappedRanges(
+      List<MappedRange> mappedRangesForElement, RetraceClassResultImpl.ElementImpl classElement) {
+    MappedRange topFrame = mappedRangesForElement.get(0);
+    MethodReference methodReference =
+        methodReferenceFromMappedRange(
+            topFrame, classElement.getRetracedClass().getClassReference());
+    return new ElementImpl(
+        this,
+        classElement,
+        getRetracedMethod(methodReference, topFrame, obfuscatedPosition),
+        mappedRangesForElement,
+        obfuscatedPosition);
+  }
+
+  @Override
+  public RetraceFrameResultImpl forEach(Consumer<Element> resultConsumer) {
+    stream().forEach(resultConsumer);
+    return this;
+  }
+
+  private RetracedMethodImpl getRetracedMethod(
+      MethodReference methodReference, MappedRange mappedRange, int obfuscatedPosition) {
+    if (obfuscatedPosition == -1
+        || mappedRange.minifiedRange == null
+        || !mappedRange.minifiedRange.contains(obfuscatedPosition)) {
+      return RetracedMethodImpl.create(methodReference);
+    }
+    return RetracedMethodImpl.create(
+        methodReference, mappedRange.getOriginalLineNumber(obfuscatedPosition));
+  }
+
+  public static class ElementImpl implements RetraceFrameResult.Element {
+
+    private final RetracedMethodImpl methodReference;
+    private final RetraceFrameResultImpl retraceFrameResult;
+    private final RetraceClassResultImpl.ElementImpl classElement;
+    private final List<MappedRange> mappedRanges;
+    private final int obfuscatedPosition;
+
+    public ElementImpl(
+        RetraceFrameResultImpl retraceFrameResult,
+        RetraceClassResultImpl.ElementImpl classElement,
+        RetracedMethodImpl methodReference,
+        List<MappedRange> mappedRanges,
+        int obfuscatedPosition) {
+      this.methodReference = methodReference;
+      this.retraceFrameResult = retraceFrameResult;
+      this.classElement = classElement;
+      this.mappedRanges = mappedRanges;
+      this.obfuscatedPosition = obfuscatedPosition;
+    }
+
+    @Override
+    public boolean isUnknown() {
+      return methodReference.isUnknown();
+    }
+
+    @Override
+    public RetracedMethodImpl getTopFrame() {
+      return methodReference;
+    }
+
+    @Override
+    public RetraceClassResultImpl.ElementImpl getClassElement() {
+      return classElement;
+    }
+
+    @Override
+    public void visitFrames(BiConsumer<RetracedMethod, Integer> consumer) {
+      int counter = 0;
+      consumer.accept(getTopFrame(), counter++);
+      for (RetracedMethodImpl outerFrame : getOuterFrames()) {
+        consumer.accept(outerFrame, counter++);
+      }
+    }
+
+    @Override
+    public RetraceSourceFileResult retraceSourceFile(RetracedClassMember frame, String sourceFile) {
+      return RetraceUtils.getSourceFile(
+          classElement, frame.getHolderClass(), sourceFile, retraceFrameResult.retracer);
+    }
+
+    @Override
+    public List<RetracedMethodImpl> getOuterFrames() {
+      if (mappedRanges == null) {
+        return Collections.emptyList();
+      }
+      List<RetracedMethodImpl> outerFrames = new ArrayList<>();
+      for (int i = 1; i < mappedRanges.size(); i++) {
+        MappedRange mappedRange = mappedRanges.get(i);
+        MethodReference methodReference =
+            methodReferenceFromMappedRange(
+                mappedRange, classElement.getRetracedClass().getClassReference());
+        outerFrames.add(
+            retraceFrameResult.getRetracedMethod(methodReference, mappedRange, obfuscatedPosition));
+      }
+      return outerFrames;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceInvalidStackTraceLineDiagnostics.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceInvalidStackTraceLineDiagnostics.java
similarity index 93%
rename from src/main/java/com/android/tools/r8/retrace/RetraceInvalidStackTraceLineDiagnostics.java
rename to src/main/java/com/android/tools/r8/retrace/internal/RetraceInvalidStackTraceLineDiagnostics.java
index 959976a..547534f 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceInvalidStackTraceLineDiagnostics.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceInvalidStackTraceLineDiagnostics.java
@@ -1,8 +1,8 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.Keep;
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
new file mode 100644
index 0000000..93fa544
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
@@ -0,0 +1,174 @@
+// Copyright (c) 2019, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.retrace.RetraceMethodResult;
+import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+@Keep
+public class RetraceMethodResultImpl implements RetraceMethodResult {
+
+  private final MethodDefinition methodDefinition;
+  private final RetraceClassResultImpl classResult;
+  private final List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> mappedRanges;
+  private final RetracerImpl retracer;
+
+  RetraceMethodResultImpl(
+      RetraceClassResultImpl classResult,
+      List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> mappedRanges,
+      MethodDefinition methodDefinition,
+      RetracerImpl retracer) {
+    this.classResult = classResult;
+    this.mappedRanges = mappedRanges;
+    this.methodDefinition = methodDefinition;
+    this.retracer = retracer;
+    assert classResult != null;
+    assert !mappedRanges.isEmpty();
+  }
+
+  @Override
+  public boolean isAmbiguous() {
+    if (mappedRanges.size() > 1) {
+      return true;
+    }
+    List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
+    if (methodRanges == null || methodRanges.isEmpty()) {
+      return false;
+    }
+    MappedRange lastRange = methodRanges.get(0);
+    for (MappedRange mappedRange : methodRanges) {
+      if (mappedRange != lastRange
+          && (mappedRange.minifiedRange == null
+              || !mappedRange.minifiedRange.equals(lastRange.minifiedRange))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public RetraceFrameResultImpl narrowByPosition(int position) {
+    List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> narrowedRanges =
+        new ArrayList<>();
+    List<Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>>> noMappingRanges =
+        new ArrayList<>();
+    for (Pair<RetraceClassResultImpl.ElementImpl, List<MappedRange>> mappedRange : mappedRanges) {
+      if (mappedRange.getSecond() == null) {
+        noMappingRanges.add(new Pair<>(mappedRange.getFirst(), null));
+        continue;
+      }
+      List<MappedRange> ranges =
+          new MappedRangesOfName(mappedRange.getSecond()).allRangesForLine(position, false);
+      boolean hasAddedRanges = false;
+      if (!ranges.isEmpty()) {
+        narrowedRanges.add(new Pair<>(mappedRange.getFirst(), ranges));
+        hasAddedRanges = true;
+      } else {
+        narrowedRanges = new ArrayList<>();
+        for (MappedRange mapped : mappedRange.getSecond()) {
+          if (mapped.minifiedRange == null) {
+            narrowedRanges.add(new Pair<>(mappedRange.getFirst(), ImmutableList.of(mapped)));
+            hasAddedRanges = true;
+          }
+        }
+      }
+      if (!hasAddedRanges) {
+        narrowedRanges.add(new Pair<>(mappedRange.getFirst(), null));
+      }
+    }
+    return new RetraceFrameResultImpl(
+        classResult,
+        narrowedRanges.isEmpty() ? noMappingRanges : narrowedRanges,
+        methodDefinition,
+        position,
+        retracer);
+  }
+
+  @Override
+  public Stream<Element> stream() {
+    return mappedRanges.stream()
+        .flatMap(
+            mappedRangePair -> {
+              RetraceClassResultImpl.ElementImpl classElement = mappedRangePair.getFirst();
+              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
+              if (mappedRanges == null || mappedRanges.isEmpty()) {
+                return Stream.of(
+                    new ElementImpl(
+                        this,
+                        classElement,
+                        RetracedMethodImpl.create(
+                            methodDefinition.substituteHolder(
+                                classElement.getRetracedClass().getClassReference()))));
+              }
+              return mappedRanges.stream()
+                  .map(
+                      mappedRange -> {
+                        MethodReference methodReference =
+                            RetraceUtils.methodReferenceFromMappedRange(
+                                mappedRange, classElement.getRetracedClass().getClassReference());
+                        return new ElementImpl(
+                            this, classElement, RetracedMethodImpl.create(methodReference));
+                      });
+            });
+  }
+
+  @Override
+  public RetraceMethodResultImpl forEach(Consumer<Element> resultConsumer) {
+    stream().forEach(resultConsumer);
+    return this;
+  }
+
+  public static class ElementImpl implements RetraceMethodResult.Element {
+
+    private final RetracedMethodImpl methodReference;
+    private final RetraceMethodResultImpl retraceMethodResult;
+    private final RetraceClassResultImpl.ElementImpl classElement;
+
+    private ElementImpl(
+        RetraceMethodResultImpl retraceMethodResult,
+        RetraceClassResultImpl.ElementImpl classElement,
+        RetracedMethodImpl methodReference) {
+      this.classElement = classElement;
+      this.retraceMethodResult = retraceMethodResult;
+      this.methodReference = methodReference;
+    }
+
+    @Override
+    public boolean isUnknown() {
+      return methodReference.isUnknown();
+    }
+
+    @Override
+    public com.android.tools.r8.retrace.RetracedMethod getRetracedMethod() {
+      return null;
+    }
+
+    @Override
+    public RetraceMethodResultImpl getRetraceMethodResult() {
+      return retraceMethodResult;
+    }
+
+    @Override
+    public RetraceClassResultImpl.ElementImpl getClassElement() {
+      return classElement;
+    }
+
+    @Override
+    public com.android.tools.r8.retrace.RetraceSourceFileResult retraceSourceFile(
+        String sourceFile) {
+      return RetraceUtils.getSourceFile(
+          classElement, methodReference.getHolderClass(), sourceFile, retraceMethodResult.retracer);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceRegularExpression.java
similarity index 91%
rename from src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
rename to src/main/java/com/android/tools/r8/retrace/internal/RetraceRegularExpression.java
index 910db1a..6ba4d1a 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceRegularExpression.java
@@ -2,18 +2,25 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
-import static com.android.tools.r8.retrace.RetraceUtils.methodDescriptionFromRetraceMethod;
+import static com.android.tools.r8.retrace.internal.RetraceUtils.methodDescriptionFromRetraceMethod;
 
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.retrace.RetraceClassResult.Element;
-import com.android.tools.r8.retrace.RetraceRegularExpression.ClassNameGroup.ClassNameGroupHandler;
+import com.android.tools.r8.retrace.RetraceClassResult;
+import com.android.tools.r8.retrace.RetraceFieldResult;
+import com.android.tools.r8.retrace.RetraceFrameResult;
+import com.android.tools.r8.retrace.RetraceFrameResult.Element;
+import com.android.tools.r8.retrace.RetraceSourceFileResult;
+import com.android.tools.r8.retrace.RetracedClass;
+import com.android.tools.r8.retrace.RetracedField;
 import com.android.tools.r8.retrace.RetracedField.KnownRetracedField;
+import com.android.tools.r8.retrace.RetracedMethod;
+import com.android.tools.r8.retrace.internal.RetraceRegularExpression.ClassNameGroup.ClassNameGroupHandler;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -30,7 +37,7 @@
 
 public class RetraceRegularExpression {
 
-  private final RetraceApi retracer;
+  private final RetracerImpl retracer;
   private final List<String> stackTrace;
   private final DiagnosticsHandler diagnosticsHandler;
   private final String regularExpression;
@@ -52,8 +59,8 @@
   private static final String CAPTURE_GROUP_PREFIX = "captureGroup";
   private static final int FIRST_CAPTURE_GROUP_INDEX = 0;
 
-  RetraceRegularExpression(
-      RetraceApi retracer,
+  public RetraceRegularExpression(
+      RetracerImpl retracer,
       List<String> stackTrace,
       DiagnosticsHandler diagnosticsHandler,
       String regularExpression,
@@ -134,7 +141,7 @@
               case CLASS:
                 return line.getClassContext().getRetracedClass().getTypeName();
               case METHOD:
-                return line.getMethodContext().getMember().getMethodName();
+                return line.getMethodContext().getTopFrame().getMethodName();
               case SOURCE:
                 return line.getSource();
               case LINE:
@@ -241,8 +248,8 @@
   }
 
   static class RetraceStringContext {
-    private final Element classContext;
-    private final RetraceClassMemberElement<? extends RetracedMethod> methodContext;
+    private final RetraceClassResult.Element classContext;
+    private final RetraceFrameResult.Element methodContext;
     private final RetracedClass qualifiedClassContext;
     private final RetracedMethod qualifiedMethodContext;
     private final String methodName;
@@ -252,8 +259,8 @@
     private final boolean isAmbiguous;
 
     private RetraceStringContext(
-        Element classContext,
-        RetraceClassMemberElement<? extends RetracedMethod> methodContext,
+        RetraceClassResult.Element classContext,
+        RetraceFrameResult.Element methodContext,
         RetracedClass qualifiedClassContext,
         RetracedMethod qualifiedMethodContext,
         String methodName,
@@ -278,7 +285,7 @@
     }
 
     private RetraceStringContext withClassContext(
-        Element classContext, RetracedClass qualifiedContext) {
+        RetraceClassResult.Element classContext, RetracedClass qualifiedContext) {
       return new RetraceStringContext(
           classContext,
           methodContext,
@@ -304,8 +311,7 @@
           isAmbiguous);
     }
 
-    private RetraceStringContext withMethodContext(
-        RetraceClassMemberElement<? extends RetracedMethod> methodContext, boolean isAmbiguous) {
+    private RetraceStringContext withMethodContext(Element methodContext, boolean isAmbiguous) {
       return new RetraceStringContext(
           classContext,
           methodContext,
@@ -403,11 +409,11 @@
       this.context = context;
     }
 
-    private Element getClassContext() {
+    private RetraceClassResult.Element getClassContext() {
       return context.classContext;
     }
 
-    private RetraceClassMemberElement<? extends RetracedMethod> getMethodContext() {
+    private RetraceFrameResult.Element getMethodContext() {
       return context.methodContext;
     }
 
@@ -448,10 +454,10 @@
   private interface RegularExpressionGroupHandler {
 
     List<RetraceString> handleMatch(
-        String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer);
+        String original, List<RetraceString> strings, Matcher matcher, RetracerImpl retracer);
 
     default RetraceStringContext buildInitial(
-        RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+        RetraceStringContext context, Matcher matcher, RetracerImpl retracer) {
       return context;
     }
 
@@ -518,7 +524,7 @@
 
     static class ClassNameGroupHandler implements RegularExpressionGroupHandler {
 
-      private RetraceClassResult retraceClassResult = null;
+      private RetraceClassResultImpl retraceClassResult = null;
       private final ClassNameGroup classNameGroup;
       private final String captureGroup;
       private RegularExpressionGroupHandler qualifiedHandler;
@@ -530,15 +536,15 @@
 
       @Override
       public List<RetraceString> handleMatch(
-          String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+          String original, List<RetraceString> strings, Matcher matcher, RetracerImpl retracer) {
         final int startOfGroup = matcher.start(captureGroup);
         if (startOfGroup == NO_MATCH) {
           return strings;
         }
         String typeName = matcher.group(captureGroup);
-        RetraceClassResult retraceResult =
+        RetraceClassResultImpl retraceResult =
             retraceClassResult == null
-                ? retracer.retrace(classNameGroup.classFromMatch(typeName))
+                ? retracer.retraceClass(classNameGroup.classFromMatch(typeName))
                 : retraceClassResult;
         assert !retraceResult.isAmbiguous();
         List<RetraceString> retraceStrings = new ArrayList<>(strings.size());
@@ -579,14 +585,14 @@
 
       @Override
       public RetraceStringContext buildInitial(
-          RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+          RetraceStringContext context, Matcher matcher, RetracerImpl retracer) {
         // Reset the local class context since this the same handler is used for multiple lines.
         retraceClassResult = null;
         if (matcher.start(captureGroup) == NO_MATCH || context.classContext != null) {
           return context;
         }
         String typeName = matcher.group(captureGroup);
-        retraceClassResult = retracer.retrace(classNameGroup.classFromMatch(typeName));
+        retraceClassResult = retracer.retraceClass(classNameGroup.classFromMatch(typeName));
         assert !retraceClassResult.isAmbiguous();
         Box<RetraceStringContext> box = new Box<>();
         retraceClassResult.forEach(
@@ -673,7 +679,7 @@
 
         @Override
         public List<RetraceString> handleMatch(
-            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+            String original, List<RetraceString> strings, Matcher matcher, RetracerImpl retracer) {
           final int startOfGroup = matcher.start(captureGroup);
           if (startOfGroup == NO_MATCH) {
             if (classNameGroupHandler != null) {
@@ -715,7 +721,7 @@
 
         @Override
         public RetraceStringContext buildInitial(
-            RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+            RetraceStringContext context, Matcher matcher, RetracerImpl retracer) {
           final int startOfGroup = matcher.start(captureGroup);
           if (startOfGroup == NO_MATCH || context.methodName != null) {
             return context;
@@ -728,25 +734,21 @@
     private static void retraceMethodForString(
         RetraceString retraceString,
         String methodName,
-        BiConsumer<RetraceClassMemberElement<? extends RetracedMethod>, RetraceStringContext>
-            process) {
+        BiConsumer<Element, RetraceStringContext> process) {
       if (retraceString.context.classContext == null) {
         return;
       }
-      RetraceMethodResult retraceMethodResult =
-          retraceString.getClassContext().lookupMethod(methodName);
-      Result<? extends RetraceClassMemberElement<RetracedMethod>, ?> retraceResult;
-      if (retraceString.context.minifiedLineNumber > NO_MATCH) {
-        retraceResult =
-            retraceMethodResult.narrowByPosition(retraceString.context.minifiedLineNumber);
-      } else {
-        retraceResult = retraceMethodResult;
-      }
-      retraceResult.forEach(
-          element ->
-              process.accept(
-                  element,
-                  retraceString.context.withMethodContext(element, retraceResult.isAmbiguous())));
+      RetraceClassResult.Element classContext = retraceString.getClassContext();
+      RetraceFrameResult retraceFrameResult =
+          retraceString.context.minifiedLineNumber > NO_MATCH
+              ? classContext.lookupFrame(methodName, retraceString.context.minifiedLineNumber)
+              : classContext.lookupFrame(methodName);
+      retraceFrameResult.forEach(
+          element -> {
+            process.accept(
+                element,
+                retraceString.context.withMethodContext(element, retraceFrameResult.isAmbiguous()));
+          });
     }
   }
 
@@ -776,7 +778,7 @@
 
         @Override
         public List<RetraceString> handleMatch(
-            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+            String original, List<RetraceString> strings, Matcher matcher, RetracerImpl retracer) {
           final int startOfGroup = matcher.start(captureGroup);
           if (startOfGroup == NO_MATCH) {
             if (classNameGroupHandler != null) {
@@ -878,7 +880,7 @@
     }
   }
 
-  private class LineNumberGroup extends RegularExpressionGroup {
+  private static class LineNumberGroup extends RegularExpressionGroup {
 
     @Override
     String subExpression() {
@@ -890,7 +892,7 @@
       return new RegularExpressionGroupHandler() {
         @Override
         public List<RetraceString> handleMatch(
-            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+            String original, List<RetraceString> strings, Matcher matcher, RetracerImpl retracer) {
           final int startOfGroup = matcher.start(captureGroup);
           if (startOfGroup == NO_MATCH) {
             return strings;
@@ -902,8 +904,7 @@
           int lineNumber = Integer.parseInt(lineNumberAsString);
           List<RetraceString> retracedStrings = new ArrayList<>();
           for (RetraceString retraceString : strings) {
-            RetraceClassMemberElement<? extends RetracedMethod> methodContext =
-                retraceString.context.methodContext;
+            Element methodContext = retraceString.context.methodContext;
             if (methodContext == null) {
               if (retraceString.context.classContext == null
                   || retraceString.context.methodName == null) {
@@ -961,7 +962,7 @@
 
         @Override
         public RetraceStringContext buildInitial(
-            RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+            RetraceStringContext context, Matcher matcher, RetracerImpl retracer) {
           if (matcher.start(captureGroup) == NO_MATCH || context.minifiedLineNumber > NO_MATCH) {
             return context;
           }
@@ -1015,12 +1016,12 @@
           return strings;
         }
         TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
-        RetraceTypeResult retracedType = retracer.retrace(typeReference);
+        RetraceTypeResultImpl retracedType = retracer.retraceType(typeReference);
         assert !retracedType.isAmbiguous();
         for (RetraceString retraceString : strings) {
           retracedType.forEach(
               element -> {
-                RetracedType retracedReference = element.getType();
+                RetracedTypeImpl retracedReference = element.getType();
                 retraceString.appendRetracedString(
                     original,
                     retracedReference.isVoid() ? "void" : retracedReference.getTypeName(),
@@ -1059,10 +1060,10 @@
                       if (!DescriptorUtils.isDescriptor(descriptor) && !"V".equals(descriptor)) {
                         return typeName;
                       }
-                      final RetraceTypeResult retraceResult =
-                          retracer.retrace(Reference.returnTypeFromDescriptor(descriptor));
+                      final RetraceTypeResultImpl retraceResult =
+                          retracer.retraceType(Reference.returnTypeFromDescriptor(descriptor));
                       assert !retraceResult.isAmbiguous();
-                      final Box<RetracedType> elementBox = new Box<>();
+                      final Box<RetracedTypeImpl> elementBox = new Box<>();
                       retraceResult.forEach(element -> elementBox.set(element.getType()));
                       return elementBox.get().getTypeName();
                     })
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceSourceFileResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceSourceFileResultImpl.java
new file mode 100644
index 0000000..b84b1a6
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceSourceFileResultImpl.java
@@ -0,0 +1,28 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.retrace.RetraceSourceFileResult;
+
+public class RetraceSourceFileResultImpl implements RetraceSourceFileResult {
+
+  private final String filename;
+  private final boolean synthesized;
+
+  RetraceSourceFileResultImpl(String filename, boolean synthesized) {
+    this.filename = filename;
+    this.synthesized = synthesized;
+  }
+
+  @Override
+  public boolean isSynthesized() {
+    return synthesized;
+  }
+
+  @Override
+  public String getFilename() {
+    return filename;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceTypeResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceTypeResultImpl.java
new file mode 100644
index 0000000..0680800
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceTypeResultImpl.java
@@ -0,0 +1,68 @@
+// Copyright (c) 2019, 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.retrace.internal;
+
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetraceTypeResult;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public class RetraceTypeResultImpl implements RetraceTypeResult {
+
+  private final TypeReference obfuscatedType;
+  private final RetracerImpl retracer;
+
+  private RetraceTypeResultImpl(TypeReference obfuscatedType, RetracerImpl retracer) {
+    this.obfuscatedType = obfuscatedType;
+    this.retracer = retracer;
+  }
+
+  static RetraceTypeResultImpl create(TypeReference obfuscatedType, RetracerImpl retracer) {
+    return new RetraceTypeResultImpl(obfuscatedType, retracer);
+  }
+
+  @Override
+  public Stream<Element> stream() {
+    // Handle void and primitive types as single element results.
+    if (obfuscatedType == null || obfuscatedType.isPrimitive()) {
+      return Stream.of(new ElementImpl(RetracedTypeImpl.create(obfuscatedType)));
+    }
+    if (obfuscatedType.isArray()) {
+      int dimensions = obfuscatedType.asArray().getDimensions();
+      return retracer.retraceType(obfuscatedType.asArray().getBaseType()).stream()
+          .map(
+              baseElement ->
+                  new ElementImpl(
+                      RetracedTypeImpl.create(baseElement.getType().toArray(dimensions))));
+    }
+    return retracer.retraceClass(obfuscatedType.asClass()).stream()
+        .map(classElement -> new ElementImpl(classElement.getRetracedClass().getRetracedType()));
+  }
+
+  @Override
+  public boolean isAmbiguous() {
+    return false;
+  }
+
+  @Override
+  public RetraceTypeResultImpl forEach(Consumer<Element> resultConsumer) {
+    stream().forEach(resultConsumer);
+    return this;
+  }
+
+  public static class ElementImpl implements RetraceTypeResult.Element {
+
+    private final RetracedTypeImpl retracedType;
+
+    public ElementImpl(RetracedTypeImpl retracedType) {
+      this.retracedType = retracedType;
+    }
+
+    @Override
+    public RetracedTypeImpl getType() {
+      return retracedType;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceUtils.java
similarity index 83%
rename from src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
rename to src/main/java/com/android/tools/r8/retrace/internal/RetraceUtils.java
index e402a80..46e8ddc 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceUtils.java
@@ -2,7 +2,7 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
 import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
@@ -10,6 +10,10 @@
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetraceClassResult.Element;
+import com.android.tools.r8.retrace.RetraceSourceFileResult;
+import com.android.tools.r8.retrace.RetracedClass;
+import com.android.tools.r8.retrace.RetracedMethod;
 import com.android.tools.r8.retrace.RetracedMethod.KnownRetracedMethod;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -53,14 +57,14 @@
   }
 
   public static boolean hasPredictableSourceFileName(String originalClassName, String sourceFile) {
-    String synthesizedSourceFileName = getClassSimpleName(originalClassName) + ".java";
+    String synthesizedSourceFileName = getOuterClassSimpleName(originalClassName) + ".java";
     return synthesizedSourceFileName.equals(sourceFile);
   }
 
-  private static String getClassSimpleName(String clazz) {
-    int lastIndexOfPeriod = clazz.lastIndexOf('.');
+  private static String getOuterClassSimpleName(String clazz) {
+    int lastIndexOfPeriod = clazz.lastIndexOf(DescriptorUtils.JAVA_PACKAGE_SEPARATOR);
     // Check if we can find a subclass separator.
-    int endIndex = clazz.lastIndexOf('$');
+    int endIndex = clazz.indexOf(DescriptorUtils.INNER_CLASS_SEPARATOR, lastIndexOfPeriod);
     if (lastIndexOfPeriod > endIndex || endIndex < 0) {
       endIndex = clazz.length();
     }
@@ -68,10 +72,7 @@
   }
 
   static RetraceSourceFileResult getSourceFile(
-      RetraceClassResult.Element classElement,
-      RetracedClass context,
-      String sourceFile,
-      RetraceApi retracer) {
+      Element classElement, RetracedClass context, String sourceFile, RetracerImpl retracer) {
     // If no context is specified always retrace using the found class element.
     if (context == null) {
       return classElement.retraceSourceFile(sourceFile);
@@ -79,7 +80,8 @@
     if (context.equals(classElement.getRetracedClass())) {
       return classElement.retraceSourceFile(sourceFile);
     } else {
-      RetraceClassResult contextClassResult = retracer.retrace(context.getClassReference());
+      RetraceClassResultImpl contextClassResult =
+          retracer.retraceClass(context.getClassReference());
       assert !contextClassResult.isAmbiguous();
       if (contextClassResult.hasRetraceResult()) {
         Box<RetraceSourceFileResult> retraceSourceFile = new Box<>();
@@ -87,7 +89,7 @@
             element -> retraceSourceFile.set(element.retraceSourceFile(sourceFile)));
         return retraceSourceFile.get();
       } else {
-        return new RetraceSourceFileResult(
+        return new RetraceSourceFileResultImpl(
             synthesizeFileName(
                 context.getTypeName(),
                 classElement.getRetracedClass().getTypeName(),
@@ -118,9 +120,9 @@
       // We have no mapping but but file name is unknown, so the best we can do is take the
       // name of the obfuscated clazz.
       assert minifiedClassName.equals(retracedClassName);
-      return getClassSimpleName(minifiedClassName) + "." + extension;
+      return getOuterClassSimpleName(minifiedClassName) + "." + extension;
     }
-    String newFileName = getClassSimpleName(retracedClassName);
+    String newFileName = getOuterClassSimpleName(retracedClassName);
     return newFileName + "." + extension;
   }
 
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetracedClassImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetracedClassImpl.java
new file mode 100644
index 0000000..b2da5d8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetracedClassImpl.java
@@ -0,0 +1,60 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.retrace.RetracedClass;
+
+@Keep
+public final class RetracedClassImpl implements RetracedClass {
+
+  private final ClassReference classReference;
+
+  private RetracedClassImpl(ClassReference classReference) {
+    assert classReference != null;
+    this.classReference = classReference;
+  }
+
+  public static RetracedClassImpl create(ClassReference classReference) {
+    return new RetracedClassImpl(classReference);
+  }
+
+  @Override
+  public String getTypeName() {
+    return classReference.getTypeName();
+  }
+
+  @Override
+  public String getBinaryName() {
+    return classReference.getBinaryName();
+  }
+
+  @Override
+  public RetracedTypeImpl getRetracedType() {
+    return RetracedTypeImpl.create(classReference);
+  }
+
+  @Override
+  public ClassReference getClassReference() {
+    return classReference;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    return classReference.equals(((RetracedClassImpl) o).classReference);
+  }
+
+  @Override
+  public int hashCode() {
+    return classReference.hashCode();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetracedFieldImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetracedFieldImpl.java
new file mode 100644
index 0000000..aee0cde
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetracedFieldImpl.java
@@ -0,0 +1,133 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetracedField;
+import java.util.Objects;
+
+@Keep
+public abstract class RetracedFieldImpl implements RetracedField {
+
+  private RetracedFieldImpl() {}
+
+  @Override
+  public boolean isUnknown() {
+    return true;
+  }
+
+  @Override
+  public final boolean isKnown() {
+    return !isUnknown();
+  }
+
+  @Override
+  public KnownRetracedFieldImpl asKnown() {
+    return null;
+  }
+
+  public static final class KnownRetracedFieldImpl extends RetracedFieldImpl
+      implements KnownRetracedField {
+
+    private final FieldReference fieldReference;
+
+    private KnownRetracedFieldImpl(FieldReference fieldReference) {
+      this.fieldReference = fieldReference;
+    }
+
+    @Override
+    public boolean isUnknown() {
+      return false;
+    }
+
+    @Override
+    public KnownRetracedFieldImpl asKnown() {
+      return this;
+    }
+
+    @Override
+    public RetracedClassImpl getHolderClass() {
+      return RetracedClassImpl.create(fieldReference.getHolderClass());
+    }
+
+    @Override
+    public String getFieldName() {
+      return fieldReference.getFieldName();
+    }
+
+    @Override
+    public TypeReference getFieldType() {
+      return fieldReference.getFieldType();
+    }
+
+    @Override
+    public FieldReference getFieldReference() {
+      return fieldReference;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      KnownRetracedFieldImpl that = (KnownRetracedFieldImpl) o;
+      return fieldReference.equals(that.fieldReference);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(fieldReference);
+    }
+  }
+
+  public static final class UnknownRetracedField extends RetracedFieldImpl {
+
+    private final FieldDefinition fieldDefinition;
+
+    private UnknownRetracedField(FieldDefinition fieldDefinition) {
+      this.fieldDefinition = fieldDefinition;
+    }
+
+    @Override
+    public RetracedClassImpl getHolderClass() {
+      return RetracedClassImpl.create(fieldDefinition.getHolderClass());
+    }
+
+    @Override
+    public String getFieldName() {
+      return fieldDefinition.getName();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      UnknownRetracedField that = (UnknownRetracedField) o;
+      return fieldDefinition.equals(that.fieldDefinition);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(fieldDefinition);
+    }
+  }
+
+  static RetracedFieldImpl create(FieldReference fieldReference) {
+    return new KnownRetracedFieldImpl(fieldReference);
+  }
+
+  static RetracedFieldImpl create(FieldDefinition fieldDefinition) {
+    return new UnknownRetracedField(fieldDefinition);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetracedMethodImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetracedMethodImpl.java
new file mode 100644
index 0000000..998fe7d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetracedMethodImpl.java
@@ -0,0 +1,175 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetracedMethod;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Keep
+public abstract class RetracedMethodImpl implements RetracedMethod {
+
+  private static final int NO_POSITION = -1;
+
+  private RetracedMethodImpl() {}
+
+  @Override
+  public boolean isUnknown() {
+    return true;
+  }
+
+  @Override
+  public final boolean isKnown() {
+    return !isUnknown();
+  }
+
+  @Override
+  public KnownRetracedMethodImpl asKnown() {
+    return null;
+  }
+
+  public static final class KnownRetracedMethodImpl extends RetracedMethodImpl
+      implements KnownRetracedMethod {
+
+    private final MethodReference methodReference;
+    private final int position;
+
+    private KnownRetracedMethodImpl(MethodReference methodReference, int position) {
+      assert methodReference != null;
+      this.methodReference = methodReference;
+      this.position = position;
+    }
+
+    @Override
+    public boolean isUnknown() {
+      return false;
+    }
+
+    @Override
+    public boolean isVoid() {
+      return methodReference.getReturnType() == null;
+    }
+
+    @Override
+    public KnownRetracedMethodImpl asKnown() {
+      return this;
+    }
+
+    @Override
+    public RetracedClassImpl getHolderClass() {
+      return RetracedClassImpl.create(methodReference.getHolderClass());
+    }
+
+    @Override
+    public String getMethodName() {
+      return methodReference.getMethodName();
+    }
+
+    @Override
+    public boolean hasPosition() {
+      return position != NO_POSITION;
+    }
+
+    @Override
+    public int getOriginalPositionOrDefault(int defaultPosition) {
+      return hasPosition() ? position : defaultPosition;
+    }
+
+    @Override
+    public TypeReference getReturnType() {
+      assert !isVoid();
+      return methodReference.getReturnType();
+    }
+
+    @Override
+    public List<TypeReference> getFormalTypes() {
+      return methodReference.getFormalTypes();
+    }
+
+    @Override
+    public MethodReference getMethodReference() {
+      return methodReference;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      KnownRetracedMethodImpl that = (KnownRetracedMethodImpl) o;
+      return position == that.position && methodReference.equals(that.methodReference);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(methodReference, position);
+    }
+  }
+
+  public static final class UnknownRetracedMethodImpl extends RetracedMethodImpl {
+
+    private final MethodDefinition methodDefinition;
+    private final int position;
+
+    private UnknownRetracedMethodImpl(MethodDefinition methodDefinition, int position) {
+      this.methodDefinition = methodDefinition;
+      this.position = position;
+    }
+
+    @Override
+    public RetracedClassImpl getHolderClass() {
+      return RetracedClassImpl.create(methodDefinition.getHolderClass());
+    }
+
+    @Override
+    public String getMethodName() {
+      return methodDefinition.getName();
+    }
+
+    @Override
+    public boolean hasPosition() {
+      return position != NO_POSITION;
+    }
+
+    @Override
+    public int getOriginalPositionOrDefault(int defaultPosition) {
+      return hasPosition() ? position : defaultPosition;
+    }
+
+    public Optional<MethodReference> getMethodReference() {
+      if (!methodDefinition.isFullMethodDefinition()) {
+        return Optional.empty();
+      }
+      return Optional.of(methodDefinition.asFullMethodDefinition().getMethodReference());
+    }
+  }
+
+  static RetracedMethodImpl create(MethodDefinition methodDefinition) {
+    return create(methodDefinition, NO_POSITION);
+  }
+
+  static RetracedMethodImpl create(MethodDefinition methodDefinition, int position) {
+    if (methodDefinition.isFullMethodDefinition()) {
+      return new KnownRetracedMethodImpl(
+          methodDefinition.asFullMethodDefinition().getMethodReference(), position);
+    }
+    return new UnknownRetracedMethodImpl(methodDefinition, position);
+  }
+
+  static RetracedMethodImpl create(MethodReference methodReference) {
+    return create(methodReference, NO_POSITION);
+  }
+
+  static RetracedMethodImpl create(MethodReference methodReference, int position) {
+    return new KnownRetracedMethodImpl(methodReference, position);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetracedTypeImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetracedTypeImpl.java
new file mode 100644
index 0000000..8162e05
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetracedTypeImpl.java
@@ -0,0 +1,62 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetracedType;
+import java.util.Objects;
+
+@Keep
+public final class RetracedTypeImpl implements RetracedType {
+
+  private final TypeReference typeReference;
+
+  private RetracedTypeImpl(TypeReference typeReference) {
+    this.typeReference = typeReference;
+  }
+
+  static RetracedTypeImpl create(TypeReference typeReference) {
+    return new RetracedTypeImpl(typeReference);
+  }
+
+  @Override
+  public boolean isVoid() {
+    return typeReference == null;
+  }
+
+  @Override
+  public TypeReference toArray(int dimensions) {
+    return Reference.array(typeReference, dimensions);
+  }
+
+  @Override
+  public String getTypeName() {
+    assert !isVoid();
+    return typeReference.getTypeName();
+  }
+
+  @Override
+  public TypeReference getTypeReference() {
+    return typeReference;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    return typeReference.equals(((RetracedTypeImpl) o).typeReference);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(typeReference);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetracerImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetracerImpl.java
new file mode 100644
index 0000000..eed4f28
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetracerImpl.java
@@ -0,0 +1,70 @@
+// Copyright (c) 2019, 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.retrace.internal;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.InvalidMappingFileException;
+import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
+import com.android.tools.r8.retrace.Retracer;
+
+/** A default implementation for the retrace api using the ClassNameMapper defined in R8. */
+public class RetracerImpl implements Retracer {
+
+  private final ClassNameMapper classNameMapper;
+
+  private RetracerImpl(ClassNameMapper classNameMapper) {
+    this.classNameMapper = classNameMapper;
+    assert classNameMapper != null;
+  }
+
+  public static RetracerImpl create(
+      ProguardMapProducer proguardMapProducer, DiagnosticsHandler diagnosticsHandler) {
+    if (proguardMapProducer instanceof DirectClassNameMapperProguardMapProducer) {
+      return new RetracerImpl(
+          ((DirectClassNameMapperProguardMapProducer) proguardMapProducer).getClassNameMapper());
+    }
+    try {
+      ClassNameMapper classNameMapper =
+          ClassNameMapper.mapperFromString(proguardMapProducer.get(), diagnosticsHandler);
+      return new RetracerImpl(classNameMapper);
+    } catch (Throwable throwable) {
+      throw new InvalidMappingFileException(throwable);
+    }
+  }
+
+  @Override
+  public RetraceMethodResultImpl retraceMethod(MethodReference methodReference) {
+    return retraceClass(methodReference.getHolderClass())
+        .lookupMethod(methodReference.getMethodName());
+  }
+
+  @Override
+  public RetraceFrameResultImpl retraceFrame(MethodReference methodReference, int position) {
+    return retraceClass(methodReference.getHolderClass())
+        .lookupMethod(methodReference.getMethodName())
+        .narrowByPosition(position);
+  }
+
+  @Override
+  public RetraceFieldResultImpl retraceField(FieldReference fieldReference) {
+    return retraceClass(fieldReference.getHolderClass()).lookupField(fieldReference.getFieldName());
+  }
+
+  @Override
+  public RetraceClassResultImpl retraceClass(ClassReference classReference) {
+    return RetraceClassResultImpl.create(
+        classReference, classNameMapper.getClassNaming(classReference.getTypeName()), this);
+  }
+
+  @Override
+  public RetraceTypeResultImpl retraceType(TypeReference typeReference) {
+    return RetraceTypeResultImpl.create(typeReference, this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementProxyRetracerImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementProxyRetracerImpl.java
new file mode 100644
index 0000000..c21b92d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementProxyRetracerImpl.java
@@ -0,0 +1,207 @@
+// Copyright (c) 2020, 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.retrace.internal;
+
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.retrace.RetraceStackTraceProxy;
+import com.android.tools.r8.retrace.RetracedClass;
+import com.android.tools.r8.retrace.RetracedMethod;
+import com.android.tools.r8.retrace.StackTraceElementProxy;
+import com.android.tools.r8.retrace.StackTraceElementProxyRetracer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class StackTraceElementProxyRetracerImpl<T extends StackTraceElementProxy<?>>
+    implements StackTraceElementProxyRetracer<T> {
+
+  private final RetracerImpl retracer;
+
+  public StackTraceElementProxyRetracerImpl(RetracerImpl retracer) {
+    this.retracer = retracer;
+  }
+
+  @Override
+  public Stream<RetraceStackTraceProxyImpl<T>> retrace(T element) {
+    if (!element.hasClassName()) {
+      return Stream.of(RetraceStackTraceProxyImpl.builder(element).build());
+    }
+    RetraceClassResultImpl classResult =
+        retracer.retraceClass(Reference.classFromTypeName(element.className()));
+    List<RetraceStackTraceProxyImpl<T>> retracedProxies = new ArrayList<>();
+    if (!element.hasMethodName()) {
+      classResult.forEach(
+          classElement -> {
+            RetraceStackTraceProxyImpl.Builder<T> proxy =
+                RetraceStackTraceProxyImpl.builder(element)
+                    .setRetracedClassElement(classElement.getRetracedClass())
+                    .setAmbiguous(classResult.isAmbiguous());
+            if (element.hasFileName()) {
+              proxy.setSourceFile(classElement.retraceSourceFile(element.fileName()).getFilename());
+            }
+            retracedProxies.add(proxy.build());
+          });
+    } else {
+      RetraceFrameResultImpl frameResult =
+          element.hasLineNumber()
+              ? classResult.lookupFrame(element.methodName(), element.lineNumber())
+              : classResult.lookupFrame(element.methodName());
+      frameResult.forEach(
+          frameElement -> {
+            frameElement.visitFrames(
+                (frame, index) -> {
+                  RetraceStackTraceProxyImpl.Builder<T> proxy =
+                      RetraceStackTraceProxyImpl.builder(element)
+                          .setRetracedClassElement(frame.getHolderClass())
+                          .setRetracedMethodElement(frame)
+                          .setAmbiguous(frameResult.isAmbiguous() && index == 0);
+                  if (element.hasLineNumber()) {
+                    proxy.setLineNumber(frame.getOriginalPositionOrDefault(element.lineNumber()));
+                  }
+                  if (element.hasFileName()) {
+                    proxy.setSourceFile(
+                        frameElement.retraceSourceFile(frame, element.fileName()).getFilename());
+                  }
+                  retracedProxies.add(proxy.build());
+                });
+          });
+    }
+    return retracedProxies.stream();
+  }
+
+  public static class RetraceStackTraceProxyImpl<T extends StackTraceElementProxy<?>>
+      implements RetraceStackTraceProxy<T> {
+
+    private final T originalItem;
+    private final RetracedClass retracedClass;
+    private final RetracedMethod retracedMethod;
+    private final String sourceFile;
+    private final int lineNumber;
+    private final boolean isAmbiguous;
+
+    private RetraceStackTraceProxyImpl(
+        T originalItem,
+        RetracedClass retracedClass,
+        RetracedMethod retracedMethod,
+        String sourceFile,
+        int lineNumber,
+        boolean isAmbiguous) {
+      assert originalItem != null;
+      this.originalItem = originalItem;
+      this.retracedClass = retracedClass;
+      this.retracedMethod = retracedMethod;
+      this.sourceFile = sourceFile;
+      this.lineNumber = lineNumber;
+      this.isAmbiguous = isAmbiguous;
+    }
+
+    @Override
+    public boolean isAmbiguous() {
+      return isAmbiguous;
+    }
+
+    @Override
+    public boolean hasRetracedClass() {
+      return retracedClass != null;
+    }
+
+    @Override
+    public boolean hasRetracedMethod() {
+      return retracedMethod != null;
+    }
+
+    @Override
+    public boolean hasSourceFile() {
+      return sourceFile != null;
+    }
+
+    @Override
+    public boolean hasLineNumber() {
+      return lineNumber != -1;
+    }
+
+    @Override
+    public T getOriginalItem() {
+      return originalItem;
+    }
+
+    @Override
+    public RetracedClass getRetracedClass() {
+      return retracedClass;
+    }
+
+    @Override
+    public RetracedMethod getRetracedMethod() {
+      return retracedMethod;
+    }
+
+    @Override
+    public String getSourceFile() {
+      return sourceFile;
+    }
+
+    private static <T extends StackTraceElementProxy<?>> Builder<T> builder(T originalElement) {
+      return new Builder<>(originalElement);
+    }
+
+    @Override
+    public int getLineNumber() {
+      return lineNumber;
+    }
+
+    private static class Builder<T extends StackTraceElementProxy<?>> {
+
+      private final T originalElement;
+      private RetracedClass classContext;
+      private RetracedMethod methodContext;
+      private String sourceFile;
+      private int lineNumber = -1;
+      private boolean isAmbiguous;
+
+      private Builder(T originalElement) {
+        this.originalElement = originalElement;
+      }
+
+      private Builder<T> setRetracedClassElement(RetracedClass retracedClass) {
+        this.classContext = retracedClass;
+        return this;
+      }
+
+      private Builder<T> setRetracedMethodElement(RetracedMethod methodElement) {
+        this.methodContext = methodElement;
+        return this;
+      }
+
+      private Builder<T> setSourceFile(String sourceFile) {
+        this.sourceFile = sourceFile;
+        return this;
+      }
+
+      private Builder<T> setLineNumber(int lineNumber) {
+        this.lineNumber = lineNumber;
+        return this;
+      }
+
+      private Builder<T> setAmbiguous(boolean ambiguous) {
+        this.isAmbiguous = ambiguous;
+        return this;
+      }
+
+      private RetraceStackTraceProxyImpl<T> build() {
+        RetracedClass retracedClass = classContext;
+        if (methodContext != null) {
+          retracedClass = methodContext.getHolderClass();
+        }
+        return new RetraceStackTraceProxyImpl<>(
+            originalElement,
+            retracedClass,
+            methodContext,
+            sourceFile != null ? sourceFile : null,
+            lineNumber,
+            isAmbiguous);
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/StackTraceElementStringProxy.java b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
similarity index 90%
rename from src/main/java/com/android/tools/r8/retrace/StackTraceElementStringProxy.java
rename to src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
index dc21cbe..202d297 100644
--- a/src/main/java/com/android/tools/r8/retrace/StackTraceElementStringProxy.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
@@ -2,12 +2,13 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
-import static com.android.tools.r8.retrace.PlainStackTraceVisitor.firstNonWhiteSpaceCharacterFromIndex;
-import static com.android.tools.r8.retrace.StackTraceElementStringProxy.StringIndex.noIndex;
+import static com.android.tools.r8.retrace.internal.PlainStackTraceVisitor.firstNonWhiteSpaceCharacterFromIndex;
+import static com.android.tools.r8.retrace.internal.StackTraceElementStringProxy.StringIndex.noIndex;
 
-import com.android.tools.r8.retrace.StackTraceElementProxyRetracer.RetraceStackTraceProxy;
+import com.android.tools.r8.retrace.StackTraceElementProxy;
+import com.android.tools.r8.retrace.internal.StackTraceElementProxyRetracerImpl.RetraceStackTraceProxyImpl;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.BiFunction;
@@ -88,7 +89,8 @@
   }
 
   public String toRetracedItem(
-      RetraceStackTraceProxy<StackTraceElementStringProxy> retracedProxy, boolean printAmbiguous) {
+      RetraceStackTraceProxyImpl<StackTraceElementStringProxy> retracedProxy,
+      boolean printAmbiguous) {
     StringBuilder sb = new StringBuilder();
     int lastSeenIndex = 0;
     if (retracedProxy.isAmbiguous() && printAmbiguous) {
@@ -203,7 +205,7 @@
     private final int startIndex;
     private final int endIndex;
     private final BiFunction<
-            RetraceStackTraceProxy<StackTraceElementStringProxy>,
+            RetraceStackTraceProxyImpl<StackTraceElementStringProxy>,
             StackTraceElementStringProxy,
             String>
         retracedString;
@@ -212,7 +214,7 @@
         int startIndex,
         int endIndex,
         BiFunction<
-                RetraceStackTraceProxy<StackTraceElementStringProxy>,
+                RetraceStackTraceProxyImpl<StackTraceElementStringProxy>,
                 StackTraceElementStringProxy,
                 String>
             retracedString) {
diff --git a/src/main/java/com/android/tools/r8/retrace/StackTraceVisitor.java b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceVisitor.java
similarity index 77%
rename from src/main/java/com/android/tools/r8/retrace/StackTraceVisitor.java
rename to src/main/java/com/android/tools/r8/retrace/internal/StackTraceVisitor.java
index fd9c822..dfe937a 100644
--- a/src/main/java/com/android/tools/r8/retrace/StackTraceVisitor.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceVisitor.java
@@ -2,8 +2,9 @@
 // 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.retrace;
+package com.android.tools.r8.retrace.internal;
 
+import com.android.tools.r8.retrace.StackTraceElementProxy;
 import java.util.function.Consumer;
 
 public interface StackTraceVisitor<T extends StackTraceElementProxy<?>> {
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index d5bc317..7c6d911 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -905,6 +905,10 @@
     return this;
   }
 
+  public boolean isClassInliningAllowed(DexProgramClass clazz) {
+    return !isPinned(clazz) && !neverClassInline.contains(clazz.getType());
+  }
+
   public boolean isMinificationAllowed(DexReference reference) {
     return options().isMinificationEnabled()
         && keepInfo.getInfo(reference, this).isMinificationAllowed(options());
@@ -938,6 +942,11 @@
     return keepInfo.isPinned(reference, this);
   }
 
+  public boolean isPinned(DexDefinition definition) {
+    assert definition != null;
+    return isPinned(definition.toReference());
+  }
+
   public boolean hasPinnedInstanceInitializer(DexType type) {
     assert type.isClassType();
     DexProgramClass clazz = asProgramClassOrNull(definitionFor(type));
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
index d0834d5..9ccbf5e 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
@@ -223,7 +223,10 @@
       keepClassInfo.forEach(
           (type, info) -> {
             DexType newType = lens.lookupType(type);
-            assert newType == type || !info.isPinned() || info.isMinificationAllowed(options);
+            assert newType == type
+                || !info.isPinned()
+                || info.isMinificationAllowed(options)
+                || info.isRepackagingAllowed(options);
             KeepClassInfo previous = newClassInfo.put(newType, info);
             assert previous == null;
           });
diff --git a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
index 28d1ed5..32ca59a 100644
--- a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
@@ -166,16 +166,28 @@
   public static void withMainProgramHandler(MainAction action) {
     try {
       action.run();
-    } catch (CompilationFailedException | AbortException e) {
+    } catch (CompilationFailedException e) {
+      throw exitWithError(e, e.getCause());
+    } catch (RuntimeException e) {
+      throw exitWithError(e, e);
+    }
+  }
+
+  private static RuntimeException exitWithError(Throwable e, Throwable cause) {
+    if (isExpectedException(cause)) {
       // Detail of the errors were already reported
       System.err.println("Compilation failed");
       System.exit(STATUS_ERROR);
-    } catch (RuntimeException e) {
-      System.err.println("Compilation failed with an internal error.");
-      Throwable cause = e.getCause() == null ? e : e.getCause();
-      cause.printStackTrace();
-      System.exit(STATUS_ERROR);
+      throw null;
     }
+    System.err.println("Compilation failed with an internal error.");
+    e.printStackTrace();
+    System.exit(STATUS_ERROR);
+    throw null;
+  }
+
+  private static boolean isExpectedException(Throwable e) {
+    return e instanceof CompilationError || e instanceof AbortException;
   }
 
   // We should try to avoid the use of this extraction as it signifies a point where we don't have
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 c1fe00e..f4c003e 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -352,12 +352,10 @@
             .setCompilationMode(debug ? CompilationMode.DEBUG : CompilationMode.RELEASE)
             .setBackend(isGeneratingClassFiles() ? Backend.CF : Backend.DEX)
             .setHasChecksums(encodeChecksums);
-    // Compiling with D8 and L8 is always with a min API level and desugaring to that level. If
-    // desugaring is explicitly turned off for D8 the input is expected to already have been
-    // desugared to the specified min API level. For R8 desugaring is optional.
-    if (tool == Tool.D8
-        || tool == Tool.L8
-        || (tool == Tool.R8 && desugarState != DesugarState.OFF)) {
+    // The marker records the min API if any desugaring happens or if the compiler generates dex
+    // since the output depends on the min API in this case. There is basically no min API entry
+    // in R8 cf to cf.
+    if (isGeneratingDex() || desugarState == DesugarState.ON) {
       marker.setMinApi(minApiLevel);
     }
     if (desugaredLibraryConfiguration.getIdentifier() != null) {
@@ -1307,7 +1305,6 @@
     public PrintStream whyAreYouNotInliningConsumer = System.out;
     public boolean trackDesugaredAPIConversions =
         System.getProperty("com.android.tools.r8.trackDesugaredAPIConversions") != null;
-    public boolean forceLibBackportsInL8CfToCf = false;
     public boolean enumUnboxingRewriteJavaCGeneratedMethod = false;
     // TODO(b/154793333): Enable assertions always when resolved.
     public boolean assertConsistentRenamingOfSignature = false;
diff --git a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
index 2272f50..f2358c5 100644
--- a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
+++ b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
@@ -48,7 +48,7 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.naming.Range;
 import com.android.tools.r8.naming.mappinginformation.FileNameInformation;
-import com.android.tools.r8.retrace.RetraceUtils;
+import com.android.tools.r8.retrace.internal.RetraceUtils;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
 import com.google.common.base.Suppliers;
diff --git a/src/main/java/com/android/tools/r8/utils/Reporter.java b/src/main/java/com/android/tools/r8/utils/Reporter.java
index 43f4f57..4e476e3 100644
--- a/src/main/java/com/android/tools/r8/utils/Reporter.java
+++ b/src/main/java/com/android/tools/r8/utils/Reporter.java
@@ -11,10 +11,38 @@
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.DiagnosticsLevel;
 import com.android.tools.r8.errors.Unreachable;
+import java.util.ArrayList;
+import java.util.List;
 
 public class Reporter implements DiagnosticsHandler {
 
+  private static class DiagnosticsLevelMapping {
+    private final DiagnosticsLevel from;
+    private final DiagnosticsLevel to;
+    private final String diagnosticsClassName;
+
+    public DiagnosticsLevelMapping(
+        DiagnosticsLevel from, DiagnosticsLevel to, String diagnosticsClassName) {
+      this.from = from;
+      this.to = to;
+      this.diagnosticsClassName = diagnosticsClassName;
+    }
+
+    public DiagnosticsLevel map(DiagnosticsLevel level, Diagnostic diagnostic) {
+      if (level != from) {
+        return level;
+      }
+      if (diagnosticsClassName.length() == 0
+          || diagnosticsClassName.equals(diagnostic.getClass().getSimpleName())
+          || diagnosticsClassName.equals(diagnostic.getClass().getTypeName())) {
+        return to;
+      }
+      return level;
+    }
+  }
+
   private final DiagnosticsHandler clientHandler;
+  private final List<DiagnosticsLevelMapping> diagnosticsLevelMapping = new ArrayList<>();
   private AbortException abort = null;
 
   public Reporter() {
@@ -31,6 +59,7 @@
     if (level != null) {
       DiagnosticsLevel modifiedLevel = clientHandler.modifyDiagnosticsLevel(level, diagnostic);
       level = modifiedLevel != null ? modifiedLevel : level;
+      level = mapDiagnosticsLevel(level, diagnostic);
     } else {
       level = ERROR;
     }
@@ -55,6 +84,10 @@
     handleDiagnostic(INFO, info);
   }
 
+  public void info(String message) {
+    info(new StringDiagnostic(message));
+  }
+
   @Override
   public synchronized void warning(Diagnostic warning) {
     handleDiagnostic(WARNING, warning);
@@ -94,4 +127,16 @@
       throw new RuntimeException(abort);
     }
   }
+
+  private DiagnosticsLevel mapDiagnosticsLevel(DiagnosticsLevel level, Diagnostic diagnostic) {
+    for (DiagnosticsLevelMapping diagnosticsLevelMapping : diagnosticsLevelMapping) {
+      level = diagnosticsLevelMapping.map(level, diagnostic);
+    }
+    return level;
+  }
+
+  public void addDiagnosticsLevelMapping(
+      DiagnosticsLevel from, String diagnosticsClassName, DiagnosticsLevel to) {
+    diagnosticsLevelMapping.add(new DiagnosticsLevelMapping(from, to, diagnosticsClassName));
+  }
 }
diff --git a/src/main/keep.txt b/src/main/keep.txt
index 84423da..f8bbc12 100644
--- a/src/main/keep.txt
+++ b/src/main/keep.txt
@@ -21,6 +21,7 @@
 -keepattributes SourceFile, LineNumberTable, InnerClasses, EnclosingMethod, Exceptions, Signature
 
 -keeppackagenames com.android.tools.r8
+-repackageclasses com.android.tools.r8.internal
 
 # Compatibility command line program used by the Android Platform build.
 -keep public class com.android.tools.r8.compatproguard.CompatProguard { public static void main(java.lang.String[]); }
diff --git a/src/test/java/com/android/tools/r8/CommandTestBase.java b/src/test/java/com/android/tools/r8/CommandTestBase.java
new file mode 100644
index 0000000..dcfbeca
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/CommandTestBase.java
@@ -0,0 +1,315 @@
+// Copyright (c) 2020, 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.fail;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+
+public abstract class CommandTestBase<C extends BaseCompilerCommand> extends TestBase {
+  private void mapDiagnosticsMissingArguments(String... args) throws Exception {
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Missing argument(s) for --map-diagnostics", handler -> parse(handler, args));
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void mapDiagnosticsMissingArguments() throws Exception {
+    mapDiagnosticsMissingArguments("--map-diagnostics");
+    mapDiagnosticsMissingArguments("--map-diagnostics", "error");
+    mapDiagnosticsMissingArguments("--map-diagnostics", "warning");
+    mapDiagnosticsMissingArguments("--map-diagnostics", "info");
+    mapDiagnosticsMissingArguments("--map-diagnostics", "xxx");
+  }
+
+  private void mapDiagnosticsInvalidArguments(String... args) throws Exception {
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Invalid diagnostics level 'xxx'", handler -> parse(handler, args));
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void mapDiagnosticsInvalidArguments() throws Exception {
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "error", "xxx");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "warning", "xxx");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "info", "xxx");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "xxx", "xxx");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "xxx", "error");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "xxx", "warning");
+    mapDiagnosticsInvalidArguments("--map-diagnostics", "xxx", "info");
+    mapDiagnosticsInvalidArguments("--debug", "--map-diagnostics", "error", "xxx", "--debug");
+  }
+
+  @Test
+  public void mapDiagnosticsInvalidArgumentsMoreErrors() throws Exception {
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          ImmutableList.of("Invalid diagnostics level 'xxx'", "Unknown option: --xxx"),
+          handler -> parse(handler, "--debug", "--map-diagnostics", "error", "xxx", "--xxx"));
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void errorsToWarnings() throws Exception {
+    DiagnosticsChecker.checkWarningsContains(
+        "Error",
+        handler -> {
+          C command = parseWithRequiredArgs(handler, "--map-diagnostics", "error", "warning");
+          command.getReporter().error("Error");
+        });
+
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Test diagnostic",
+          handler -> {
+            C command =
+                parseWithRequiredArgs(handler, "--map-diagnostics:a.b.C", "error", "warning");
+            command.getReporter().error(new TestDiagnostic());
+            try {
+              command.getReporter().failIfPendingErrors();
+            } catch (RuntimeException e) {
+              throw new CompilationFailedException();
+            }
+          });
+      fail("Failure expected");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+
+    DiagnosticsChecker.checkWarningsContains(
+        "Test diagnostic",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler,
+                  "--map-diagnostics:com.android.tools.r8.TestDiagnostic",
+                  "error",
+                  "warning");
+          command.getReporter().error(new TestDiagnostic());
+        });
+
+    DiagnosticsChecker.checkWarningsContains(
+        "Test diagnostic",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler, "--map-diagnostics:TestDiagnostic", "error", "warning");
+          command.getReporter().error(new TestDiagnostic());
+        });
+  }
+
+  @Test
+  public void errorsToInfo() throws Exception {
+    DiagnosticsChecker.checkInfosContains(
+        "Error",
+        handler -> {
+          C command = parseWithRequiredArgs(handler, "--map-diagnostics", "error", "info");
+          command.getReporter().error("Error");
+        });
+
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Test diagnostic",
+          handler -> {
+            C command = parseWithRequiredArgs(handler, "--map-diagnostics:a.b.C", "error", "info");
+            command.getReporter().error(new TestDiagnostic());
+            try {
+              command.getReporter().failIfPendingErrors();
+            } catch (RuntimeException e) {
+              throw new CompilationFailedException();
+            }
+          });
+      fail("Failure expected");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+
+    DiagnosticsChecker.checkInfosContains(
+        "Test diagnostic",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(handler, "--map-diagnostics:TestDiagnostic", "error", "info");
+          command.getReporter().error(new TestDiagnostic());
+        });
+  }
+
+  @Test
+  public void warningsToInfo() throws Exception {
+    DiagnosticsChecker.checkInfosContains(
+        "Warning",
+        handler -> {
+          C command = parseWithRequiredArgs(handler, "--map-diagnostics", "warning", "info");
+          command.getReporter().warning("Warning");
+        });
+
+    DiagnosticsChecker.checkInfosContains(
+        "Test diagnostic",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(handler, "--map-diagnostics:TestDiagnostic", "warning", "info");
+          command.getReporter().warning(new TestDiagnostic());
+        });
+  }
+
+  @Test
+  public void warningsToError() throws Exception {
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Warning",
+          handler -> {
+            C command = parseWithRequiredArgs(handler, "--map-diagnostics", "warning", "error");
+            command.getReporter().warning("Warning");
+            try {
+              command.getReporter().failIfPendingErrors();
+            } catch (RuntimeException e) {
+              throw new CompilationFailedException();
+            }
+          });
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+
+    try {
+      DiagnosticsChecker.checkErrorsContains(
+          "Test diagnostic",
+          handler -> {
+            C command =
+                parseWithRequiredArgs(
+                    handler, "--map-diagnostics:TestDiagnostic", "warning", "error");
+            command.getReporter().warning(new TestDiagnostic());
+            try {
+              command.getReporter().failIfPendingErrors();
+            } catch (RuntimeException e) {
+              throw new CompilationFailedException();
+            }
+          });
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void errorsToWarningsWarningsToInfos() throws Exception {
+    DiagnosticsChecker.checkInfosContains(
+        "Error",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler,
+                  "--map-diagnostics",
+                  "error",
+                  "warning",
+                  "--map-diagnostics",
+                  "warning",
+                  "info");
+          command.getReporter().error("Error");
+        });
+
+    DiagnosticsChecker.checkInfosContains(
+        "Test diagnostic",
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler,
+                  "--map-diagnostics:TestDiagnostic",
+                  "error",
+                  "warning",
+                  "--map-diagnostics",
+                  "warning",
+                  "info");
+          command.getReporter().error(new TestDiagnostic());
+        });
+  }
+
+  @Test
+  public void warningsToInfosErrorsToWarnings() throws Exception {
+    DiagnosticsChecker.checkDiagnostics(
+        diagnostics -> {
+          assertEquals(0, diagnostics.errors.size());
+          diagnostics.checkWarningsContains("Error");
+          diagnostics.checkInfosContains("Warning");
+        },
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler,
+                  "--map-diagnostics",
+                  "warning",
+                  "info",
+                  "--map-diagnostics",
+                  "error",
+                  "warning");
+          command.getReporter().error("Error");
+          command.getReporter().warning("Warning");
+        });
+
+    DiagnosticsChecker.checkDiagnostics(
+        diagnostics -> {
+          assertEquals(0, diagnostics.errors.size());
+          diagnostics.checkWarningsContains("Test diagnostic");
+          diagnostics.checkInfosContains("Test diagnostic");
+        },
+        handler -> {
+          C command =
+              parseWithRequiredArgs(
+                  handler,
+                  "--map-diagnostics:TestDiagnostic",
+                  "warning",
+                  "info",
+                  "--map-diagnostics:TestDiagnostic",
+                  "error",
+                  "warning");
+          command.getReporter().error(new TestDiagnostic());
+          command.getReporter().warning(new TestDiagnostic());
+        });
+  }
+
+  private String[] prepareArgs(String[] args) {
+    String[] actualTestArgs;
+    String[] additionalTestArgs = requiredArgsForTest();
+    if (additionalTestArgs.length > 0) {
+      actualTestArgs = new String[args.length + additionalTestArgs.length];
+      System.arraycopy(additionalTestArgs, 0, actualTestArgs, 0, additionalTestArgs.length);
+      System.arraycopy(args, 0, actualTestArgs, additionalTestArgs.length, args.length);
+    } else {
+      actualTestArgs = args;
+    }
+    return actualTestArgs;
+  }
+
+  private C parseWithRequiredArgs(String... args) throws CompilationFailedException {
+    return parse(prepareArgs(args));
+  }
+
+  private C parseWithRequiredArgs(DiagnosticsHandler handler, String... args)
+      throws CompilationFailedException {
+    return parse(handler, prepareArgs(args));
+  }
+
+  /**
+   * Tests in this class are executed for all of D8, R8 and L8. When testing arguments this can add
+   * additional required arguments to all tests
+   */
+  abstract String[] requiredArgsForTest();
+
+  abstract C parse(String... args) throws CompilationFailedException;
+
+  abstract C parse(DiagnosticsHandler handler, String... args) throws CompilationFailedException;
+}
diff --git a/src/test/java/com/android/tools/r8/D8CommandTest.java b/src/test/java/com/android/tools/r8/D8CommandTest.java
index 5be6b85..9b80b80 100644
--- a/src/test/java/com/android/tools/r8/D8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/D8CommandTest.java
@@ -43,7 +43,7 @@
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
-public class D8CommandTest extends TestBase {
+public class D8CommandTest extends CommandTestBase<D8Command> {
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
@@ -657,12 +657,18 @@
     numThreadsOptionInvalid("two");
   }
 
-  private D8Command parse(String... args) throws CompilationFailedException {
+  @Override
+  String[] requiredArgsForTest() {
+    return new String[0];
+  }
+
+  @Override
+  D8Command parse(String... args) throws CompilationFailedException {
     return D8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
   }
 
-  private D8Command parse(DiagnosticsHandler handler, String... args)
-      throws CompilationFailedException {
+  @Override
+  D8Command parse(DiagnosticsHandler handler, String... args) throws CompilationFailedException {
     return D8Command.parse(args, EmbeddedOrigin.INSTANCE, handler).build();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/DiagnosticsChecker.java b/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
index b62416f..730d952 100644
--- a/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
+++ b/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
@@ -14,13 +14,16 @@
 import com.android.tools.r8.position.TextPosition;
 import com.android.tools.r8.position.TextRange;
 import com.android.tools.r8.utils.ListUtils;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.function.Consumer;
 
 // Helper to check that a particular error occurred.
 public class DiagnosticsChecker implements DiagnosticsHandler {
+
   public List<Diagnostic> errors = new ArrayList<>();
   public List<Diagnostic> warnings = new ArrayList<>();
   public List<Diagnostic> infos = new ArrayList<>();
@@ -41,6 +44,7 @@
   }
 
   public interface FailingRunner {
+
     void run(DiagnosticsHandler handler) throws CompilationFailedException;
   }
 
@@ -56,18 +60,38 @@
         diagnostics.stream().anyMatch(d -> d.getDiagnosticMessage().contains(snippet)));
   }
 
+  public void checkWarningsContains(String snippet) {
+    checkContains(snippet, warnings);
+  }
+
+  public void checkInfosContains(String snippet) {
+    checkContains(snippet, infos);
+  }
+
   public static void checkErrorsContains(String snippet, FailingRunner runner)
       throws CompilationFailedException {
+    checkErrorsContains(ImmutableList.of(snippet), runner);
+  }
+
+  public static void checkErrorsContains(Collection<String> snippets, FailingRunner runner)
+      throws CompilationFailedException {
     DiagnosticsChecker handler = new DiagnosticsChecker();
     try {
       runner.run(handler);
       fail("Failure expected");
     } catch (CompilationFailedException e) {
-      checkContains(snippet, handler.errors);
+      snippets.forEach(snippet -> checkContains(snippet, handler.errors));
       throw e;
     }
   }
 
+  public static void checkDiagnostics(Consumer<DiagnosticsChecker> checker, FailingRunner runner)
+      throws CompilationFailedException {
+    DiagnosticsChecker handler = new DiagnosticsChecker();
+    runner.run(handler);
+    checker.accept(handler);
+  }
+
   public static void checkWarningsContains(String snippet, FailingRunner runner)
       throws CompilationFailedException {
     DiagnosticsChecker handler = new DiagnosticsChecker();
@@ -75,6 +99,13 @@
     checkContains(snippet, handler.warnings);
   }
 
+  public static void checkInfosContains(String snippet, FailingRunner runner)
+      throws CompilationFailedException {
+    DiagnosticsChecker handler = new DiagnosticsChecker();
+    runner.run(handler);
+    checkContains(snippet, handler.infos);
+  }
+
   public static Diagnostic checkDiagnostic(Diagnostic diagnostic, Consumer<Origin> originChecker,
       int lineStart, int columnStart, String... messageParts) {
     if (originChecker != null) {
diff --git a/src/test/java/com/android/tools/r8/L8CommandTest.java b/src/test/java/com/android/tools/r8/L8CommandTest.java
index c83cd38..978c382 100644
--- a/src/test/java/com/android/tools/r8/L8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/L8CommandTest.java
@@ -36,7 +36,7 @@
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
-public class L8CommandTest extends TestBase {
+public class L8CommandTest extends CommandTestBase<L8Command> {
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
@@ -435,12 +435,18 @@
     numThreadsOptionInvalid("two");
   }
 
-  private L8Command parse(String... args) throws CompilationFailedException {
+  @Override
+  String[] requiredArgsForTest() {
+    return new String[] {"--desugared-lib", ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING.toString()};
+  }
+
+  @Override
+  L8Command parse(String... args) throws CompilationFailedException {
     return L8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
   }
 
-  private L8Command parse(DiagnosticsHandler handler, String... args)
-      throws CompilationFailedException {
+  @Override
+  L8Command parse(DiagnosticsHandler handler, String... args) throws CompilationFailedException {
     return L8Command.parse(args, EmbeddedOrigin.INSTANCE, handler).build();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/MarkersTest.java b/src/test/java/com/android/tools/r8/MarkersTest.java
index 1fdc6ae..6e99dc4 100644
--- a/src/test/java/com/android/tools/r8/MarkersTest.java
+++ b/src/test/java/com/android/tools/r8/MarkersTest.java
@@ -87,18 +87,18 @@
             markerCompilationMode(compilationMode),
             markerDesugaredLibraryIdentifier("com.tools.android:desugar_jdk_libs:" + version),
             markerHasChecksums(false));
-    Matcher<Marker> d8Matcher =
+    Matcher<Marker> r8Matcher =
         allOf(
             markerTool(Tool.R8),
             markerCompilationMode(compilationMode),
             markerMinApi(apiLevel),
             markerR8Mode("compatibility"));
-    Matcher<Marker> r8Matcher =
+    Matcher<Marker> d8Matcher =
         allOf(markerTool(Tool.D8), markerCompilationMode(compilationMode), markerMinApi(apiLevel));
     if (shrinkDesugaredLibrary) {
-      assertMarkersMatch(markers, ImmutableList.of(l8Matcher, d8Matcher));
-    } else {
       assertMarkersMatch(markers, ImmutableList.of(l8Matcher, r8Matcher));
+    } else {
+      assertMarkersMatch(markers, ImmutableList.of(l8Matcher, d8Matcher));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
index 27d4655..622d595 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -27,6 +27,9 @@
     extends TestShrinkerBuilder<
         R8Command, Builder, ProguardTestCompileResult, ProguardTestRunResult, ProguardTestBuilder> {
 
+  // Version of Proguard to use.
+  private final ProguardVersion version;
+
   // Ordered list of injar entries.
   private List<Path> injars = new ArrayList<>();
 
@@ -39,12 +42,14 @@
   // Additional Proguard configuration files.
   private List<Path> proguardConfigFiles = new ArrayList<>();
 
-  private ProguardTestBuilder(TestState state, Builder builder, Backend backend) {
+  private ProguardTestBuilder(
+      TestState state, ProguardVersion version, Builder builder, Backend backend) {
     super(state, builder, backend);
+    this.version = version;
   }
 
-  public static ProguardTestBuilder create(TestState state) {
-    return new ProguardTestBuilder(state, R8Command.builder(), Backend.CF);
+  public static ProguardTestBuilder create(TestState state, ProguardVersion version) {
+    return new ProguardTestBuilder(state, version, R8Command.builder(), Backend.CF);
   }
 
   @Override
@@ -63,7 +68,7 @@
       Path mapFile = proguardOutputFolder.resolve("mapping.txt");
       FileUtils.writeTextFile(configFile, config);
       List<String> command = new ArrayList<>();
-      command.add(ToolHelper.getProguard6Script());
+      command.add(version.getProguardScript().toString());
       // Without -forceprocessing Proguard just checks the creation time on the in/out jars.
       command.add("-forceprocessing");
       for (Path injar : injars) {
diff --git a/src/test/java/com/android/tools/r8/ProguardVersion.java b/src/test/java/com/android/tools/r8/ProguardVersion.java
new file mode 100644
index 0000000..8c9050a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ProguardVersion.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.ToolHelper.isWindows;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public enum ProguardVersion {
+  V5_2_1("5.2.1"),
+  V6_0_1("6.0.1"),
+  V7_0_0("7.0.0");
+
+  private final String version;
+
+  ProguardVersion(String version) {
+    this.version = version;
+  }
+
+  public Path getProguardScript() {
+    Path scriptDirectory = Paths.get(ToolHelper.THIRD_PARTY_DIR).resolve("proguard");
+    if (this == V7_0_0) {
+      scriptDirectory = scriptDirectory.resolve("proguard-" + version);
+    } else {
+      scriptDirectory = scriptDirectory.resolve("proguard" + version);
+    }
+    if (isWindows()) {
+      return scriptDirectory.resolve("bin/proguard.bat");
+    }
+    return scriptDirectory.resolve("bin/proguard.sh");
+  }
+
+  @Override
+  public String toString() {
+    return "Proguard " + version.toString();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/R8CommandTest.java b/src/test/java/com/android/tools/r8/R8CommandTest.java
index 149c3c3..2f94aeb 100644
--- a/src/test/java/com/android/tools/r8/R8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/R8CommandTest.java
@@ -45,7 +45,7 @@
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
-public class R8CommandTest extends TestBase {
+public class R8CommandTest extends CommandTestBase<R8Command> {
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
@@ -820,12 +820,18 @@
     numThreadsOptionInvalid("two");
   }
 
-  private R8Command parse(String... args) throws CompilationFailedException {
+  @Override
+  String[] requiredArgsForTest() {
+    return new String[0];
+  }
+
+  @Override
+  R8Command parse(String... args) throws CompilationFailedException {
     return R8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
   }
 
-  private R8Command parse(DiagnosticsHandler handler, String... args)
-      throws CompilationFailedException {
+  @Override
+  R8Command parse(DiagnosticsHandler handler, String... args) throws CompilationFailedException {
     return R8Command.parse(args, EmbeddedOrigin.INSTANCE, handler).build();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index a92fefd..27c1570 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -172,8 +172,8 @@
     return JvmTestBuilder.create(new TestState(temp));
   }
 
-  public static ProguardTestBuilder testForProguard(TemporaryFolder temp) {
-    return ProguardTestBuilder.create(new TestState(temp));
+  public static ProguardTestBuilder testForProguard(ProguardVersion version, TemporaryFolder temp) {
+    return ProguardTestBuilder.create(new TestState(temp), version);
   }
 
   public static GenerateMainDexListTestBuilder testForMainDexListGenerator(TemporaryFolder temp) {
@@ -308,8 +308,14 @@
     return DesugarTestBuilder.create(state, builders.build());
   }
 
+  /** @deprecated use {@link #testForProguard(ProguardVersion)} instead. */
+  @Deprecated
   public ProguardTestBuilder testForProguard() {
-    return testForProguard(temp);
+    return testForProguard(ProguardVersion.V6_0_1);
+  }
+
+  public ProguardTestBuilder testForProguard(ProguardVersion version) {
+    return testForProguard(version, temp);
   }
 
   public GenerateMainDexListTestBuilder testForMainDexListGenerator() {
diff --git a/src/test/java/com/android/tools/r8/TestDiagnostic.java b/src/test/java/com/android/tools/r8/TestDiagnostic.java
new file mode 100644
index 0000000..b5df861
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestDiagnostic.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2020, 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.position.Position;
+
+class TestDiagnostic implements Diagnostic {
+
+  @Override
+  public Origin getOrigin() {
+    return Origin.unknown();
+  }
+
+  @Override
+  public Position getPosition() {
+    return null;
+  }
+
+  @Override
+  public String getDiagnosticMessage() {
+    return "Test diagnostic";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index 477aab1..5f674e0 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -94,6 +94,10 @@
     return addKeepRules(Arrays.asList(rules));
   }
 
+  public T addDontWarn(Class<?> clazz) {
+    return addKeepRules("-dontwarn " + clazz.getTypeName());
+  }
+
   public T addKeepKotlinMetadata() {
     return addKeepRules("-keep class kotlin.Metadata { *; }");
   }
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 7e1a627..9676011 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -702,7 +702,7 @@
     }
   }
 
-  public static String getProguardScript() {
+  public static String getProguard5Script() {
     if (isWindows()) {
       return PROGUARD + ".bat";
     }
@@ -1922,17 +1922,17 @@
 
   public static ProcessResult runProguardRaw(
       Path inJar, Path outJar, Path lib, Path config, Path map) throws IOException {
-    return runProguardRaw(getProguardScript(), inJar, outJar, lib, ImmutableList.of(config), map);
+    return runProguardRaw(getProguard5Script(), inJar, outJar, lib, ImmutableList.of(config), map);
   }
 
   public static ProcessResult runProguardRaw(Path inJar, Path outJar, List<Path> config, Path map)
       throws IOException {
-    return runProguardRaw(getProguardScript(), inJar, outJar, config, map);
+    return runProguardRaw(getProguard5Script(), inJar, outJar, config, map);
   }
 
   public static ProcessResult runProguardRaw(Path inJar, Path outJar, Path config, Path map)
       throws IOException {
-    return runProguardRaw(getProguardScript(), inJar, outJar, ImmutableList.of(config), map);
+    return runProguardRaw(getProguard5Script(), inJar, outJar, ImmutableList.of(config), map);
   }
 
   public static String runProguard(Path inJar, Path outJar, Path config, Path map)
@@ -1942,7 +1942,7 @@
 
   public static String runProguard(Path inJar, Path outJar, List<Path> config, Path map)
       throws IOException {
-    return runProguard(getProguardScript(), inJar, outJar, config, map);
+    return runProguard(getProguard5Script(), inJar, outJar, config, map);
   }
 
   public static ProcessResult runProguard6Raw(Path inJar, Path outJar, Path config, Path map)
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithRetargetedLibMemberTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithRetargetedLibMemberTest.java
index 982fb65..4a81ae5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithRetargetedLibMemberTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithRetargetedLibMemberTest.java
@@ -4,17 +4,14 @@
 
 package com.android.tools.r8.classmerging.vertical;
 
-import static org.hamcrest.CoreMatchers.containsString;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.errors.InternalCompilerError;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -37,21 +34,21 @@
 
   @Test
   public void test() throws Exception {
-    try {
-      testForR8(parameters.getBackend())
-          .addInnerClasses(getClass())
-          .addKeepMainRule(TestClass.class)
-          .enableCoreLibraryDesugaring(parameters.getApiLevel())
-          .enableNeverClassInliningAnnotations()
-          .setMinApi(parameters.getApiLevel())
-          .compile();
-      assertTrue(parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N));
-    } catch (CompilationFailedException e) {
-      // TODO(b/170677722): Fix compilation failure.
-      assertTrue(parameters.getApiLevel().isLessThan(AndroidApiLevel.N));
-      assertTrue(e.getCause() instanceof InternalCompilerError);
-      assertThat(e.getCause().getMessage(), containsString("FORCE inlining on non-inlinable"));
-    }
+    // Regression test for b/170677722.
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .addVerticallyMergedClassesInspector(
+            inspector -> inspector.assertMergedIntoSubtype(A.class))
+        .enableCoreLibraryDesugaring(parameters.getApiLevel())
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              assertThat(inspector.clazz(A.class), not(isPresent()));
+              assertThat(inspector.clazz(B.class), isPresent());
+            });
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ConcurrentHashMapSubclassTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ConcurrentHashMapSubclassTest.java
index a01a59a..9b48952 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ConcurrentHashMapSubclassTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ConcurrentHashMapSubclassTest.java
@@ -7,7 +7,6 @@
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
index ac48a3d..0707ab9 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
@@ -4,11 +4,13 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary;
 
+import static org.junit.Assert.assertEquals;
+
 import com.android.tools.r8.D8TestRunResult;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Spliterator;
@@ -55,6 +57,49 @@
   }
 
   @Test
+  public void testCustomCollectionSuperCallsD8Cf2Cf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    Path jar =
+        testForD8(Backend.CF)
+            .addInnerClasses(CustomCollectionSuperCallsTest.class)
+            .setMinApi(parameters.getApiLevel())
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .allowStdoutMessages()
+            .compile()
+            .writeToZip();
+    String desugaredLibraryKeepRules = "";
+    if (shrinkDesugaredLibrary && keepRuleConsumer.get() != null) {
+      // Collection keep rules is only implemented in the DEX writer.
+      assertEquals(0, keepRuleConsumer.get().length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+    D8TestRunResult d8TestRunResult;
+    if (parameters.getRuntime().isDex()) {
+      d8TestRunResult =
+          testForD8()
+              .addProgramFiles(jar)
+              .setMinApi(parameters.getApiLevel())
+              .disableDesugaring()
+              .allowStdoutMessages()
+              .compile()
+              .addDesugaredCoreLibraryRunClassPath(
+                  this::buildDesugaredLibrary,
+                  parameters.getApiLevel(),
+                  desugaredLibraryKeepRules,
+                  shrinkDesugaredLibrary)
+              .run(parameters.getRuntime(), Executor.class)
+              .assertSuccess();
+      assertLines2By2Correct(d8TestRunResult.getStdOut());
+    } else {
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(getDesugaredLibraryInCF(parameters, options -> {}))
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccess();
+    }
+  }
+
+  @Test
   public void testCustomCollectionSuperCallsR8() throws Exception {
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     R8TestRunResult r8TestRunResult =
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
index 3df7246..0947a55 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.D8TestRunResult;
@@ -14,6 +15,7 @@
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject.JumboStringMode;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -70,6 +72,56 @@
     assertResultCorrect(d8TestRunResult.getStdOut());
   }
 
+  @Test
+  public void testCustomCollectionD8Cf2Cf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    // Use D8 to desugar with Java classfile output.
+    Path jar =
+        testForD8(Backend.CF)
+            .addInnerClasses(CustomCollectionTest.class)
+            .setMinApi(parameters.getApiLevel())
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .compile()
+            .writeToZip();
+    if (parameters.getRuntime().isDex()) {
+      // Collection keep rules is only implemented in the DEX writer.
+      String desugaredLibraryKeepRules = keepRuleConsumer.get();
+      if (desugaredLibraryKeepRules != null) {
+        assertEquals(0, desugaredLibraryKeepRules.length());
+        desugaredLibraryKeepRules = "-keep class * { *; }";
+      }
+      D8TestRunResult d8TestRunResult =
+          testForD8()
+              .addProgramFiles(jar)
+              .setMinApi(parameters.getApiLevel())
+              .disableDesugaring()
+              .compile()
+              .assertNoMessages()
+              .inspect(
+                  inspector -> {
+                    this.assertCustomCollectionCallsCorrect(inspector);
+                  })
+              .addDesugaredCoreLibraryRunClassPath(
+                  this::buildDesugaredLibrary,
+                  parameters.getApiLevel(),
+                  desugaredLibraryKeepRules,
+                  shrinkDesugaredLibrary)
+              .run(parameters.getRuntime(), EXECUTOR)
+              .assertSuccess();
+      assertResultCorrect(d8TestRunResult.getStdOut());
+    } else {
+      // Build the desugared library in class file format.
+      Path desugaredLib = getDesugaredLibraryInCF(parameters, o -> {});
+
+      // Run on the JVM with desuagred library on classpath.
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(desugaredLib)
+          .run(parameters.getRuntime(), EXECUTOR)
+          .assertSuccess();
+    }
+  }
+
   private void assertResultCorrect(String stdOut) {
     if (requiresEmulatedInterfaceCoreLibDesugaring(parameters) && !shrinkDesugaredLibrary) {
       // When shrinking the class names are not printed correctly anymore due to minification.
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredGenericSignatureTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredGenericSignatureTest.java
index ff0141f..a3b768d 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredGenericSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredGenericSignatureTest.java
@@ -11,13 +11,14 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.nio.file.Path;
 import java.time.LocalDate;
 import java.util.List;
+import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -33,7 +34,8 @@
   @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters().withDexRuntimes().withAllApiLevels().build(), BooleanUtils.values());
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+        BooleanUtils.values());
   }
 
   public DesugaredGenericSignatureTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
@@ -43,6 +45,7 @@
 
   @Test
   public void testD8() throws Exception {
+    Assume.assumeTrue(parameters.getRuntime().isDex());
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
         .addInnerClasses(DesugaredGenericSignatureTest.class)
@@ -61,7 +64,51 @@
   }
 
   @Test
+  public void testD8Cf2Cf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+
+    Path jar =
+        testForD8(Backend.CF)
+            .addInnerClasses(DesugaredGenericSignatureTest.class)
+            .setMinApi(parameters.getApiLevel())
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .setIncludeClassesChecksum(true)
+            .setMinApi(parameters.getApiLevel())
+            .allowStdoutMessages()
+            .compile()
+            .writeToZip();
+    String desugaredLibraryKeepRules = "";
+    if (shrinkDesugaredLibrary && keepRuleConsumer.get() != null) {
+      // Collection keep rules is only implemented in the DEX writer.
+      assertEquals(0, keepRuleConsumer.get().length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+    if (parameters.getRuntime().isDex()) {
+      testForD8()
+          .addProgramFiles(jar)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .allowStdoutMessages()
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibrary,
+              parameters.getApiLevel(),
+              desugaredLibraryKeepRules,
+              shrinkDesugaredLibrary)
+          .run(parameters.getRuntime(), Main.class)
+          .assertSuccessWithOutput(EXPECTED);
+    } else {
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(getDesugaredLibraryInCF(parameters, options -> {}))
+          .run(parameters.getRuntime(), Main.class)
+          .assertSuccessWithOutput(EXPECTED);
+    }
+  }
+
+  @Test
   public void testR8() throws Exception {
+    Assume.assumeTrue(parameters.getRuntime().isDex());
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForR8(parameters.getBackend())
         .addInnerClasses(DesugaredGenericSignatureTest.class)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index e4b3869..b02b2e9 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -119,7 +119,6 @@
           options -> {
             if (extraFiles) {
               options.testing.disableL8AnnotationRemoval = true;
-              options.testing.forceLibBackportsInL8CfToCf = true;
             }
             optionsModifier.accept(options);
           });
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
index 346743b..b726614 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
@@ -93,32 +93,28 @@
             .parse(StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING));
 
     for (AndroidApiLevel apiLevel : AndroidApiLevel.values()) {
-      if (apiLevel == AndroidApiLevel.R) {
-        // Skip API level 30 for now.
+      Path compileApiLevelDirectory = directory.resolve("compile_api_level_" + apiLevel.getLevel());
+      if (apiLevel.getLevel()
+          < desugaredLibraryConfiguration.getRequiredCompilationApiLevel().getLevel()) {
+        System.out.println("!Checking " + compileApiLevelDirectory);
         continue;
       }
-
-      if (apiLevel.getLevel()
-          >= desugaredLibraryConfiguration.getRequiredCompilationApiLevel().getLevel()) {
-        Path compileApiLevelDirectory =
-            directory.resolve("compile_api_level_" + apiLevel.getLevel());
-        assertTrue(Files.exists(compileApiLevelDirectory));
-        for (AndroidApiLevel minApiLevel : AndroidApiLevel.values()) {
-          String desugaredApisBaseName =
-              "desugared_apis_" + apiLevel.getLevel() + "_" + minApiLevel.getLevel();
-          if (minApiLevel == AndroidApiLevel.L || minApiLevel == AndroidApiLevel.B) {
-            assertTrue(
-                Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt")));
-            assertTrue(
-                Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".jar")));
-            checkFileContent(
-                minApiLevel, compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt"));
-          } else {
-            assertFalse(
-                Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt")));
-            assertFalse(
-                Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".jar")));
-          }
+      assertTrue(Files.exists(compileApiLevelDirectory));
+      for (AndroidApiLevel minApiLevel : AndroidApiLevel.values()) {
+        String desugaredApisBaseName =
+            "desugared_apis_" + apiLevel.getLevel() + "_" + minApiLevel.getLevel();
+        if (minApiLevel == AndroidApiLevel.L || minApiLevel == AndroidApiLevel.B) {
+          assertTrue(
+              Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt")));
+          assertTrue(
+              Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".jar")));
+          checkFileContent(
+              minApiLevel, compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt"));
+        } else {
+          assertFalse(
+              Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".txt")));
+          assertFalse(
+              Files.exists(compileApiLevelDirectory.resolve(desugaredApisBaseName + ".jar")));
         }
       }
     }
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/StaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/StaticInterfaceMethodTest.java
index c663489..c9b2a93 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/StaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/StaticInterfaceMethodTest.java
@@ -4,10 +4,12 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary;
 
+import static org.junit.Assert.assertEquals;
+
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
+import java.nio.file.Path;
 import java.time.chrono.Chronology;
 import java.util.List;
 import java.util.Map;
@@ -28,7 +30,8 @@
   @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+        BooleanUtils.values());
   }
 
   public StaticInterfaceMethodTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
@@ -61,6 +64,45 @@
   }
 
   @Test
+  public void testStaticInterfaceMethodsD8CfToCf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    Path jar =
+        testForD8(Backend.CF)
+            .addInnerClasses(StaticInterfaceMethodTest.class)
+            .setMinApi(parameters.getApiLevel())
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .compile()
+            .writeToZip();
+
+    String desugaredLibraryKeepRules = "";
+    if (shrinkDesugaredLibrary && keepRuleConsumer.get() != null) {
+      // Collection keep rules is only implemented in the DEX writer.
+      assertEquals(0, keepRuleConsumer.get().length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+    if (parameters.getRuntime().isDex()) {
+      testForD8()
+          .addProgramFiles(jar)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibrary,
+              parameters.getApiLevel(),
+              desugaredLibraryKeepRules,
+              shrinkDesugaredLibrary)
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_OUTPUT);
+    } else {
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(getDesugaredLibraryInCF(parameters, options -> {}))
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_OUTPUT);
+    }
+  }
+
+  @Test
   public void testStaticInterfaceMethodsR8() throws Exception {
     // Desugared library tests do not make sense in the Cf to Cf, and the JVM is already tested
     // in the D8 test. Just return.
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
index e8aa581..6afc3a5 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary.conversiontests;
 
+import static org.junit.Assert.assertEquals;
+
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -80,6 +82,52 @@
   }
 
   @Test
+  public void testFunctionCompositionD8Cf2Cf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    Path jar =
+        testForD8(Backend.CF)
+            .setMinApi(parameters.getApiLevel())
+            .addProgramClasses(
+                Executor.class,
+                Executor.Object1.class,
+                Executor.Object2.class,
+                Executor.Object3.class)
+            .addLibraryClasses(CustomLibClass.class)
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .compile()
+            .writeToZip();
+    String desugaredLibraryKeepRules = "";
+    if (shrinkDesugaredLibrary && keepRuleConsumer.get() != null) {
+      // Collection keep rules is only implemented in the DEX writer.
+      assertEquals(0, keepRuleConsumer.get().length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+    if (parameters.getRuntime().isDex()) {
+      testForD8()
+          .addProgramFiles(jar)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibrary,
+              parameters.getApiLevel(),
+              desugaredLibraryKeepRules,
+              shrinkDesugaredLibrary)
+          .addRunClasspathFiles(CUSTOM_LIB)
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_RESULT);
+
+    } else {
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(getDesugaredLibraryInCF(parameters, options -> {}))
+          .addRunClasspathFiles(CUSTOM_LIB)
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_RESULT);
+    }
+  }
+
+  @Test
   public void testFunctionCompositionR8() throws Exception {
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForR8(parameters.getBackend())
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
index 9d9b5cb..394f36c 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.ToolHelper.JDK_TESTS_BUILD_DIR;
 import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
 import static com.android.tools.r8.utils.FileUtils.JAVA_EXTENSION;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -37,23 +38,27 @@
 @RunWith(Parameterized.class)
 public class Jdk11StreamTests extends Jdk11DesugaredLibraryTestBase {
 
+  private final boolean useCf2Cf;
   private final TestParameters parameters;
   private final boolean shrinkDesugaredLibrary;
 
-  @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+  @Parameters(name = "{2}, shrinkDesugaredLibrary: {0}, useCf2Cf: {1}")
   public static List<Object[]> data() {
     // TODO(134732760): Support Dalvik VMs, currently fails because libjavacrypto is required and
     // present only in ART runtimes.
     return buildParameters(
         BooleanUtils.values(),
+        BooleanUtils.values(),
         getTestParameters()
             .withDexRuntimesStartingFromIncluding(Version.V5_1_1)
             .withAllApiLevels()
             .build());
   }
 
-  public Jdk11StreamTests(boolean shrinkDesugaredLibrary, TestParameters parameters) {
+  public Jdk11StreamTests(
+      boolean shrinkDesugaredLibrary, boolean useCf2Cf, TestParameters parameters) {
     this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.useCf2Cf = useCf2Cf;
     this.parameters = parameters;
   }
 
@@ -188,34 +193,71 @@
         "Requires Java base extensions, should add it when not desugaring",
         parameters.getApiLevel().getLevel() < AndroidApiLevel.N.getLevel());
 
-    D8TestCompileResult compileResult = compileStreamTestsToDex();
+    D8TestCompileResult compileResult = compileStreamTestsToDex(useCf2Cf);
     runSuccessfulTests(compileResult);
     runFailingTests(compileResult);
   }
 
-  private D8TestCompileResult compileStreamTestsToDex() throws Exception {
+  private D8TestCompileResult compileStreamTestsToDex(boolean cf2cf) throws Exception {
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     List<Path> filesToCompile =
         Arrays.stream(JDK_11_STREAM_TEST_COMPILED_FILES)
             .filter(file -> !file.toString().contains("lang/invoke"))
             .collect(Collectors.toList());
-    return testForD8()
-        .addProgramFiles(filesToCompile)
-        .addProgramFiles(getPathsFiles())
-        .addProgramFiles(getSafeVarArgsFile())
-        .addProgramFiles(testNGSupportProgramFiles())
-        .addOptionsModification(opt -> opt.testing.trackDesugaredAPIConversions = true)
-        .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
-        .setMinApi(parameters.getApiLevel())
-        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
-        .compile()
-        .addDesugaredCoreLibraryRunClassPath(
-            this::buildDesugaredLibraryWithJavaBaseExtension,
-            parameters.getApiLevel(),
-            keepRuleConsumer.get(),
-            shrinkDesugaredLibrary)
-        .withArtFrameworks()
-        .withArt6Plus64BitsLib();
+
+    if (cf2cf) {
+      Path jar =
+          testForD8(Backend.CF)
+              .addProgramFiles(filesToCompile)
+              .addProgramFiles(getPathsFiles())
+              .addProgramFiles(getSafeVarArgsFile())
+              .addProgramFiles(testNGSupportProgramFiles())
+              .addOptionsModification(opt -> opt.testing.trackDesugaredAPIConversions = true)
+              .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+              .setMinApi(parameters.getApiLevel())
+              .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+              .allowStdoutMessages()
+              .compile()
+              .writeToZip();
+      // Collection keep rules is only implemented in the DEX writer.
+      String desugaredLibraryKeepRules = keepRuleConsumer.get();
+      if (desugaredLibraryKeepRules != null) {
+        assertEquals(0, desugaredLibraryKeepRules.length());
+        desugaredLibraryKeepRules = "-keep class * { *; }";
+      }
+      return testForD8()
+          .addProgramFiles(jar)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibraryWithJavaBaseExtension,
+              parameters.getApiLevel(),
+              desugaredLibraryKeepRules,
+              shrinkDesugaredLibrary)
+          .withArtFrameworks()
+          .withArt6Plus64BitsLib();
+
+    } else {
+
+      return testForD8()
+          .addProgramFiles(filesToCompile)
+          .addProgramFiles(getPathsFiles())
+          .addProgramFiles(getSafeVarArgsFile())
+          .addProgramFiles(testNGSupportProgramFiles())
+          .addOptionsModification(opt -> opt.testing.trackDesugaredAPIConversions = true)
+          .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+          .setMinApi(parameters.getApiLevel())
+          .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibraryWithJavaBaseExtension,
+              parameters.getApiLevel(),
+              keepRuleConsumer.get(),
+              shrinkDesugaredLibrary)
+          .withArtFrameworks()
+          .withArt6Plus64BitsLib();
+    }
   }
 
   private void runSuccessfulTests(D8TestCompileResult compileResult) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/SingletonCanonicalizationWithApiLevelCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/SingletonCanonicalizationWithApiLevelCheckTest.java
new file mode 100644
index 0000000..7f5b905
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/SingletonCanonicalizationWithApiLevelCheckTest.java
@@ -0,0 +1,120 @@
+// Copyright (c) 2020, 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.optimize.canonicalization;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.io.PrintStream;
+import java.nio.file.Path;
+import java.util.List;
+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 SingletonCanonicalizationWithApiLevelCheckTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return TestBase.getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public SingletonCanonicalizationWithApiLevelCheckTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    Path program =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(TestClass.class, Companion.class, A.class)
+            .addLibraryClasses(LibraryVersion.class, LibraryInterfaceAddedInApi1.class)
+            .addDefaultRuntimeLibrary(parameters)
+            .addKeepMainRule(TestClass.class)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .writeToZip();
+
+    // Run with library version 1 that includes LibraryInterfaceAddedInApi1.
+    testForR8(parameters.getBackend())
+        .addProgramClasses(LibraryVersion.class, LibraryInterfaceAddedInApi1.class)
+        .addKeepAllClassesRule()
+        .addKeepRules(getAssumeValuesRule(1))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .addRunClasspathFiles(program)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("A");
+
+    // Run with library version 0 that does not include LibraryInterfaceAddedInApi1.
+    testForR8(parameters.getBackend())
+        .addProgramClasses(LibraryVersion.class)
+        .addKeepAllClassesRule()
+        .addKeepRules(getAssumeValuesRule(0))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .addRunClasspathFiles(program)
+        .run(parameters.getRuntime(), TestClass.class)
+        .apply(
+            runResult -> {
+              if (parameters.isCfRuntime()) {
+                // Constant canonicalization is disabled for CF.
+                runResult.assertSuccessWithEmptyOutput();
+              } else {
+                runResult.assertFailureWithErrorThatThrows(NoClassDefFoundError.class);
+              }
+            });
+  }
+
+  private List<String> getAssumeValuesRule(int version) {
+    return ImmutableList.of(
+        "-assumevalues class " + LibraryVersion.class.getTypeName() + " {",
+        "  static int init() return " + version + ";",
+        "}");
+  }
+
+  public static class LibraryVersion {
+
+    public static int SDK_INT = init();
+
+    private static int init() {
+      return 0;
+    }
+  }
+
+  public interface LibraryInterfaceAddedInApi1 {}
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      if (LibraryVersion.SDK_INT >= 1) {
+        PrintStream out = System.out;
+        if (System.currentTimeMillis() > 0) {
+          out.println(Companion.INSTANCE);
+        } else {
+          out.print(Companion.INSTANCE);
+        }
+      }
+    }
+  }
+
+  static class Companion {
+
+    static A INSTANCE = new A();
+  }
+
+  static class A implements LibraryInterfaceAddedInApi1 {
+
+    @Override
+    public String toString() {
+      return "A";
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
index 95fef57..415a868 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
@@ -5,13 +5,12 @@
 package com.android.tools.r8.ir.optimize.inliner;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.AndroidApiLevel;
 import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -41,14 +40,10 @@
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspect(
-            inspector -> {
-              // TODO(b/171197204): Method should be inlined.
-              assertThat(
-                  inspector.clazz(TestClass.class).uniqueMethodWithName("test"),
-                  notIf(
-                      isPresent(),
-                      parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)));
-            });
+            inspector ->
+                assertThat(
+                    inspector.clazz(TestClass.class).uniqueMethodWithName("test"),
+                    not(isPresent())));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingTest.java b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingTest.java
new file mode 100644
index 0000000..ed90756
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingTest.java
@@ -0,0 +1,123 @@
+// Copyright (c) 2020, 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.memberrebinding;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.nio.file.Path;
+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 LibraryMemberRebindingTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return TestBase.getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public LibraryMemberRebindingTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testWithEmptyA() throws Exception {
+    Path compileTimeLibrary = compileLibraryForAppCompilation(LibraryB.class, LibraryA.class);
+    test(compileTimeLibrary, compileTimeLibrary);
+  }
+
+  @Test
+  public void testWithEmptyB() throws Exception {
+    Path compileTimeLibrary = compileLibraryForAppCompilation(LibraryA.class, LibraryB.class);
+    test(compileTimeLibrary, compileTimeLibrary);
+  }
+
+  @Test
+  public void testWithEmptyBOnlyAtCompileTime() throws Exception {
+    Path compileTimeLibrary = compileLibraryForAppCompilation(LibraryA.class, LibraryB.class);
+    Path runtimeLibrary = compileLibraryForAppCompilation(LibraryB.class, LibraryA.class);
+    test(compileTimeLibrary, runtimeLibrary);
+  }
+
+  private void test(Path compileTimeLibrary, Path runtimeLibrary) throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addKeepMainRule(TestClass.class)
+        .addLibraryFiles(compileTimeLibrary)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .apply(compileResult -> configureRunClasspath(compileResult, runtimeLibrary))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("42");
+  }
+
+  private Path compileLibraryForAppCompilation(
+      Class<?> nonEmptyLibraryClass, Class<?> emptyLibraryClass) throws Exception {
+    return testForR8(Backend.CF)
+        .addProgramClasses(nonEmptyLibraryClass)
+        .addProgramClassFileData(
+            transformer(emptyLibraryClass)
+                .removeFields(
+                    (int access, String name, String descriptor, String signature, Object value) ->
+                        true)
+                .removeMethods(
+                    (int access,
+                        String name,
+                        String descriptor,
+                        String signature,
+                        String[] exceptions) -> !name.equals("<init>"))
+                .transform())
+        .addKeepAllClassesRule()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .writeToZip();
+  }
+
+  private void configureRunClasspath(R8TestCompileResult compileResult, Path library)
+      throws Exception {
+    if (parameters.isCfRuntime()) {
+      compileResult.addRunClasspathFiles(library);
+    } else {
+      compileResult.addRunClasspathFiles(
+          testForD8()
+              .addProgramFiles(library)
+              .setMinApi(parameters.getApiLevel())
+              .compile()
+              .writeToZip());
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      System.out.println(LibraryB.f + LibraryB.m());
+    }
+  }
+
+  static class LibraryA {
+
+    public static int f = 21;
+
+    public static int m() {
+      return 21;
+    }
+  }
+
+  static class LibraryB extends LibraryA {
+
+    public static int f = 21;
+
+    public static int m() {
+      return 21;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/proguard/AllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/proguard/AllowShrinkingCompatibilityTest.java
new file mode 100644
index 0000000..ca30a1f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/proguard/AllowShrinkingCompatibilityTest.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2020, 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.proguard;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ProguardVersion;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.List;
+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 AllowShrinkingCompatibilityTest extends TestBase {
+
+  private final boolean allowOptimization;
+  private final TestParameters parameters;
+  private final ProguardVersion proguardVersion;
+
+  @Parameters(name = "{1}, {2}, allow optimization: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(),
+        getTestParameters().withCfRuntimes().build(),
+        ProguardVersion.values());
+  }
+
+  public AllowShrinkingCompatibilityTest(
+      boolean allowOptimization, TestParameters parameters, ProguardVersion proguardVersion) {
+    this.allowOptimization = allowOptimization;
+    this.parameters = parameters;
+    this.proguardVersion = proguardVersion;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForProguard(proguardVersion)
+        .addProgramClasses(TestClass.class, Companion.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules(
+            "-keep,allowshrinking"
+                + (allowOptimization ? ",allowoptimization" : "")
+                + " class "
+                + Companion.class.getTypeName()
+                + " { <methods>; }")
+        .addDontWarn(getClass())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+              assertThat(testClassSubject, isPresent());
+
+              ClassSubject companionClassSubject = inspector.clazz(Companion.class);
+              assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
+
+              MethodSubject mainMethodSubject = testClassSubject.mainMethod();
+              MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+
+              if (allowOptimization) {
+                assertTrue(
+                    testClassSubject
+                        .mainMethod()
+                        .streamInstructions()
+                        .allMatch(InstructionSubject::isReturnVoid));
+              } else {
+                assertThat(mainMethodSubject, invokesMethod(getMethodSubject));
+                assertThat(getMethodSubject, isPresent());
+              }
+            })
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      if (Companion.get() != 42) {
+        System.out.println("Hello world!");
+      }
+    }
+  }
+
+  static class Companion {
+
+    static int get() {
+      return 42;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceFieldTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceFieldTests.java
index 3a6ffe6..2b90ffc 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceFieldTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceFieldTests.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.retrace;
 
 import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.retrace.internal.RetracerImpl;
 import com.android.tools.r8.retrace.mappings.FieldsWithSameMinifiedNameMapping;
 import com.android.tools.r8.retrace.mappings.MappingForTest;
 import java.util.function.Consumer;
@@ -13,13 +14,13 @@
 public class RetraceFieldTests {
 
   @Test
-  public void testFieldsWithSameMinifiedName() throws Exception {
+  public void testFieldsWithSameMinifiedName() {
     FieldsWithSameMinifiedNameMapping mapping = new FieldsWithSameMinifiedNameMapping();
     runRetraceTest(mapping, mapping::inspect);
   }
 
-  private void runRetraceTest(MappingForTest mappingForTest, Consumer<RetraceApi> inspection)
-      throws Exception {
-    inspection.accept(Retracer.create(mappingForTest::mapping, new TestDiagnosticMessagesImpl()));
+  private void runRetraceTest(MappingForTest mappingForTest, Consumer<Retracer> inspection) {
+    inspection.accept(
+        RetracerImpl.create(mappingForTest::mapping, new TestDiagnosticMessagesImpl()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
index 4fb8389..b8b1647 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
@@ -440,7 +440,7 @@
 
           @Override
           public List<String> retracedStackTrace() {
-            return ImmutableList.of("com.android.tools.r8.R8.a(42)");
+            return ImmutableList.of("com.android.tools.r8.R8.foo(42)");
           }
 
           @Override
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
index 1b6735f..edcb118 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
@@ -15,7 +15,8 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestDiagnosticMessagesImpl;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.retrace.Retrace.RetraceAbortException;
+import com.android.tools.r8.retrace.internal.RetraceAbortException;
+import com.android.tools.r8.retrace.internal.RetracerImpl;
 import com.android.tools.r8.retrace.stacktraces.ActualBotStackTraceBase;
 import com.android.tools.r8.retrace.stacktraces.ActualIdentityStackTrace;
 import com.android.tools.r8.retrace.stacktraces.ActualRetraceBotStackTrace;
@@ -26,6 +27,7 @@
 import com.android.tools.r8.retrace.stacktraces.CircularReferenceStackTrace;
 import com.android.tools.r8.retrace.stacktraces.FileNameExtensionStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineFileNameStackTrace;
+import com.android.tools.r8.retrace.stacktraces.InlineFileNameWithInnerClassesStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineNoLineNumberStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineSourceFileContextStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineWithLineNumbersStackTrace;
@@ -85,6 +87,11 @@
   }
 
   @Test
+  public void testInlineFileNameWithInnerClassesStackTrace() {
+    runRetraceTest(new InlineFileNameWithInnerClassesStackTrace());
+  }
+
+  @Test
   public void testNullLineTrace() {
     TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
     NullStackTrace nullStackTrace = new NullStackTrace();
@@ -201,9 +208,9 @@
   }
 
   private void inspectRetraceTest(
-      StackTraceForTest stackTraceForTest, Consumer<RetraceApi> inspection) throws Exception {
+      StackTraceForTest stackTraceForTest, Consumer<Retracer> inspection) throws Exception {
     inspection.accept(
-        Retracer.create(stackTraceForTest::mapping, new TestDiagnosticMessagesImpl()));
+        RetracerImpl.create(stackTraceForTest::mapping, new TestDiagnosticMessagesImpl()));
   }
 
   private TestDiagnosticMessagesImpl runRetraceTest(StackTraceForTest stackTraceForTest) {
diff --git a/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java b/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
index 488a00a..fa9ca5f 100644
--- a/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
+++ b/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
@@ -9,8 +9,8 @@
 
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.RetraceFieldResult;
+import com.android.tools.r8.retrace.Retracer;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
@@ -25,7 +25,7 @@
         "foo.bar.Baz -> foo.bar.Baz:", "  java.lang.Object f1 -> a", "  java.lang.String f2 -> a");
   }
 
-  public void inspect(RetraceApi retracer) {
+  public void inspect(Retracer retracer) {
     FieldReference f1FieldReference =
         Reference.field(
             Reference.classFromTypeName("foo.bar.Baz"),
@@ -43,7 +43,7 @@
             "a",
             Reference.classFromTypeName("java.lang.Object"));
 
-    RetraceFieldResult result = retracer.retrace(mappedF1FieldReference);
+    RetraceFieldResult result = retracer.retraceField(mappedF1FieldReference);
     // TODO(b/169829306): Result should not be ambigious.
     assertTrue(result.isAmbiguous());
 
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineFileNameWithInnerClassesStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineFileNameWithInnerClassesStackTrace.java
new file mode 100644
index 0000000..20ed6ec
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineFileNameWithInnerClassesStackTrace.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2020, 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.retrace.stacktraces;
+
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import java.util.List;
+
+public class InlineFileNameWithInnerClassesStackTrace implements StackTraceForTest {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException",
+        "\tat com.android.tools.r8.naming.retrace.Main.main(Main.dummy:3)");
+  }
+
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException",
+        "\tat foo.Bar$Baz$Qux.baz(Bar.dummy:0)",
+        "\tat com.android.tools.r8.naming.retrace.Main.main(Main.dummy:7)");
+  }
+
+  @Override
+  public String mapping() {
+    return StringUtils.lines(
+        "com.android.tools.r8.naming.retrace.Main -> com.android.tools.r8.naming.retrace.Main:",
+        "    3:3:void foo.Bar$Baz$Qux.baz(long):0:0 -> main",
+        "    3:3:void main(java.lang.String[]):7 -> main");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/MemberFieldOverlapStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/MemberFieldOverlapStackTrace.java
index 3ca3297..080990f 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/MemberFieldOverlapStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/MemberFieldOverlapStackTrace.java
@@ -9,9 +9,9 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.RetraceFieldResult;
 import com.android.tools.r8.retrace.RetraceFieldResult.Element;
+import com.android.tools.r8.retrace.Retracer;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.Arrays;
 import java.util.List;
@@ -42,12 +42,12 @@
     return 1;
   }
 
-  public void inspectField(RetraceApi retracer) {
+  public void inspectField(Retracer retracer) {
     RetraceFieldResult result =
-        retracer.retrace(Reference.classFromTypeName("a.A")).lookupField("a");
+        retracer.retraceClass(Reference.classFromTypeName("a.A")).lookupField("a");
     assertFalse(result.isAmbiguous());
     assertEquals(1, result.stream().count());
-    Optional<Element> field = result.stream().findFirst();
+    Optional<? extends Element> field = result.stream().findFirst();
     assertTrue(field.isPresent());
     assertEquals("field", field.get().getField().getFieldName());
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
index 222c6a8..c15fb48 100644
--- a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
@@ -3175,4 +3175,33 @@
           }
         });
   }
+
+  @Test
+  public void parseKeepXNamesIsAllowShrinking() {
+    for (String rule : ImmutableList.of("-keep", "-keepclassmembers", "-keepclasseswithmembers")) {
+      for (String modifier :
+          ImmutableList.of("", "names", ",allowshrinking", "names,allowshrinking")) {
+        DexItemFactory dexItemFactory = new DexItemFactory();
+        ProguardConfigurationParser parser =
+            new ProguardConfigurationParser(dexItemFactory, reporter);
+        String ruleWithModifier =
+            (rule.endsWith("s") && (!modifier.startsWith(",") && !modifier.isEmpty())
+                    ? rule.substring(0, rule.length() - 1)
+                    : rule)
+                + modifier;
+        parser.parse(
+            createConfigurationForTesting(ImmutableList.of(ruleWithModifier + " class A")));
+        verifyParserEndsCleanly();
+
+        ProguardConfiguration configuration = parser.getConfig();
+        assertEquals(1, configuration.getRules().size());
+        assertEquals(
+            !modifier.isEmpty(),
+            ListUtils.first(configuration.getRules())
+                .asProguardKeepRule()
+                .getModifiers()
+                .allowsShrinking);
+      }
+    }
+  }
 }
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepEnclosingMethodForKeptMethodTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepEnclosingMethodForKeptMethodTest.java
new file mode 100644
index 0000000..cc1f241
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepEnclosingMethodForKeptMethodTest.java
@@ -0,0 +1,129 @@
+// Copyright (c) 2020, 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.shaking.attributes;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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 KeepEnclosingMethodForKeptMethodTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final String[] EXPECTED = {
+    "null",
+    "class com.android.tools.r8.shaking.attributes.KeepEnclosingMethodForKeptMethodTest"
+        + "$KeptClass",
+    "public static com.android.tools.r8.shaking.attributes.KeepEnclosingMethodForKeptMethodTest$I "
+        + "com.android.tools.r8.shaking.attributes.KeepEnclosingMethodForKeptMethodTest$KeptClass.enclosingFromKeptMethod()",
+    "public"
+        + " com.android.tools.r8.shaking.attributes.KeepEnclosingMethodForKeptMethodTest$KeptClass()"
+  };
+  private final String[] R8_OUTPUT = {
+    "null",
+    "class com.android.tools.r8.shaking.attributes.KeepEnclosingMethodForKeptMethodTest"
+        + "$KeptClass",
+    "null",
+    "null"
+  };
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public KeepEnclosingMethodForKeptMethodTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addInnerClasses(KeptClass.class)
+        .addProgramClassFileData(
+            transformer(I.class).removeInnerClasses().transform(),
+            transformer(KeptClass.class).removeInnerClasses().transform())
+        .run(parameters.getRuntime(), KeptClass.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8Full() throws Exception {
+    // TODO(b/171194649): This should output EXPECTED.
+    runTest(testForR8(parameters.getBackend())).assertSuccessWithOutputLines(R8_OUTPUT);
+  }
+
+  @Test
+  public void testR8Compat() throws Exception {
+    runTest(testForR8Compat(parameters.getBackend())).assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  private R8TestRunResult runTest(R8TestBuilder<?> testBuilder) throws Exception {
+    return testBuilder
+        .addInnerClasses(KeptClass.class)
+        .addProgramClassFileData(
+            transformer(I.class).removeInnerClasses().transform(),
+            transformer(KeptClass.class).removeInnerClasses().transform())
+        .addKeepClassRules(I.class)
+        .addKeepAttributeInnerClassesAndEnclosingMethod()
+        .addKeepMainRule(KeptClass.class)
+        .addKeepClassAndMembersRules(KeptClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), KeptClass.class);
+  }
+
+  public interface I {
+
+    void foo();
+  }
+
+  public static class KeptClass {
+
+    static I staticField =
+        new I() {
+          @Override
+          public void foo() {
+            System.out.println(this.getClass().getEnclosingConstructor());
+            System.out.println(this.getClass().getEnclosingClass());
+          }
+        };
+
+    private I instanceField;
+
+    public KeptClass() {
+      instanceField =
+          new I() {
+            @Override
+            public void foo() {
+              System.out.println(this.getClass().getEnclosingConstructor());
+            }
+          };
+    }
+
+    public static void main(String[] args) {
+      staticField.foo();
+      enclosingFromKeptMethod().foo();
+      new KeptClass().instanceField.foo();
+    }
+
+    @NeverInline
+    public static I enclosingFromKeptMethod() {
+      return new I() {
+        @Override
+        public void foo() {
+          System.out.println(this.getClass().getEnclosingMethod());
+        }
+      };
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 1772e48..d2518b6 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -34,9 +34,9 @@
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.DirectClassNameMapperProguardMapProducer;
-import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.Retracer;
+import com.android.tools.r8.retrace.internal.DirectClassNameMapperProguardMapProducer;
+import com.android.tools.r8.retrace.internal.RetracerImpl;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.BiMapContainer;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -463,8 +463,8 @@
     }
   }
 
-  public RetraceApi retrace() {
-    return Retracer.create(
+  public Retracer retrace() {
+    return RetracerImpl.create(
         new InternalProguardMapProducer(
             mapping == null ? ClassNameMapper.builder().build() : mapping),
         new TestDiagnosticMessagesImpl());
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 bcedc29..d8aa792 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
@@ -31,9 +31,9 @@
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.RetraceTypeResult;
 import com.android.tools.r8.retrace.RetracedField;
+import com.android.tools.r8.retrace.Retracer;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ZipUtils;
@@ -223,7 +223,7 @@
 
   // TODO(b/169882658): This should be removed when we have identity mappings for ambiguous cases.
   public FieldSubject uniqueFieldWithName(String name, TypeReference originalType) {
-    RetraceApi retracer = codeInspector.retrace();
+    Retracer retracer = codeInspector.retrace();
     Set<FoundFieldSubject> candidates = Sets.newIdentityHashSet();
     Set<FoundFieldSubject> sameTypeCandidates = Sets.newIdentityHashSet();
     for (FoundFieldSubject candidate : allFields()) {
@@ -236,7 +236,7 @@
         }
       }
       retracer
-          .retrace(fieldReference)
+          .retraceField(fieldReference)
           .forEach(
               element -> {
                 RetracedField field = element.getField();
@@ -246,7 +246,7 @@
                   TypeReference fieldOriginalType = originalType;
                   if (fieldOriginalType == null) {
                     RetraceTypeResult retraceTypeResult =
-                        retracer.retrace(fieldReference.getFieldType());
+                        retracer.retraceType(fieldReference.getFieldType());
                     assert !retraceTypeResult.isAmbiguous();
                     fieldOriginalType =
                         retraceTypeResult.stream().iterator().next().getType().getTypeReference();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index 6f6bbf8..e6e26fd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -6,9 +6,9 @@
 
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.RetraceFrameResult;
 import com.android.tools.r8.retrace.RetraceMethodResult;
+import com.android.tools.r8.retrace.Retracer;
 
 public interface InstructionSubject {
 
@@ -132,17 +132,17 @@
     return lineNumberTable == null ? -1 : lineNumberTable.getLineForInstruction(this);
   }
 
-  default RetraceMethodResult retrace(RetraceApi retracer) {
+  default RetraceMethodResult retrace(Retracer retracer) {
     MethodSubject methodSubject = getMethodSubject();
     assert methodSubject.isPresent();
-    return retracer.retrace(methodSubject.asFoundMethodSubject().asMethodReference());
+    return retracer.retraceMethod(methodSubject.asFoundMethodSubject().asMethodReference());
   }
 
-  default RetraceFrameResult retraceLinePosition(RetraceApi retracer) {
+  default RetraceFrameResult retraceLinePosition(Retracer retracer) {
     return retrace(retracer).narrowByPosition(getLineNumber());
   }
 
-  default RetraceFrameResult retracePcPosition(RetraceApi retracer, MethodSubject methodSubject) {
+  default RetraceFrameResult retracePcPosition(Retracer retracer, MethodSubject methodSubject) {
     return retrace(retracer).narrowByPosition(getOffset(methodSubject).offset);
   }
 }