diff --git a/build.gradle b/build.gradle
index db4592a..812b438 100644
--- a/build.gradle
+++ b/build.gradle
@@ -646,6 +646,12 @@
 }
 
 setJdkCompilationWithCompatibility(
+        sourceSets.main.compileJavaTaskName,
+        'jdk-11',
+        JavaVersion.VERSION_11,
+        false);
+
+setJdkCompilationWithCompatibility(
         sourceSets.examplesJava9.compileJavaTaskName,
         'openjdk-9.0.4',
         JavaVersion.VERSION_1_9,
@@ -1037,7 +1043,7 @@
             input,
             "--output", output,
             "--pg-map-output", output + ".map",
-            "--lib", "third_party/openjdk/openjdk-rt-1.8/rt.jar"
+            "--lib", org.gradle.internal.jvm.Jvm.current().javaHome,
     ] + args + libs.collectMany { ["--lib", it] } + pgConfs.collectMany { ["--pg-conf", it] }
     return baseR8CommandLine(allArgs)
 }
diff --git a/src/library_desugar/jdk11/desugar_jdk_libs.json b/src/library_desugar/jdk11/desugar_jdk_libs.json
index 5adf5d1..9332de7 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs.json
@@ -6,6 +6,22 @@
   "support_all_callbacks_from_library": true,
   "common_flags": [
     {
+      "api_level_below_or_equal": 32,
+      "rewrite_prefix": {
+        "java.util.concurrent.DesugarTimeUnit": "j$.util.concurrent.DesugarTimeUnit"
+      },
+      "retarget_method": {
+        "java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)": "java.util.concurrent.DesugarTimeUnit",
+        "java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()": "java.util.concurrent.DesugarTimeUnit",
+        "long java.util.concurrent.TimeUnit#convert(java.time.Duration)": "java.util.concurrent.DesugarTimeUnit"
+      },
+      "amend_library_method": [
+        "public static java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)",
+        "public java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()",
+        "public long java.util.concurrent.TimeUnit#convert(java.time.Duration)"
+      ]
+    },
+    {
       "api_level_below_or_equal": 30,
       "rewrite_prefix": {
         "java.time.": "j$.time.",
@@ -20,8 +36,7 @@
         "java.time.ZonedDateTime java.util.GregorianCalendar#toZonedDateTime()": "java.util.DesugarGregorianCalendar"
       },
       "wrapper_conversion": [
-        "java.time.Clock",
-        "java.time.temporal.ChronoUnit"
+        "java.time.Clock"
       ],
       "custom_conversion": {
         "java.time.Duration": "java.time.TimeConversions",
diff --git a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
index 8d31143..5a1d513 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
@@ -10,12 +10,21 @@
       "rewrite_prefix": {
         "java.net.URLDecoder": "j$.net.URLDecoder",
         "java.net.URLEncoder": "j$.net.URLEncoder",
-        "java.io.DesugarInputStream": "j$.io.DesugarInputStream"
+        "java.io.DesugarInputStream": "j$.io.DesugarInputStream",
+        "java.util.concurrent.DesugarTimeUnit": "j$.util.concurrent.DesugarTimeUnit"
+      },
+      "retarget_method": {
+        "java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)": "java.util.concurrent.DesugarTimeUnit",
+        "java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()": "java.util.concurrent.DesugarTimeUnit",
+        "long java.util.concurrent.TimeUnit#convert(java.time.Duration)": "java.util.concurrent.DesugarTimeUnit"
       },
       "retarget_method_with_emulated_dispatch": {
         "long java.io.InputStream#transferTo(java.io.OutputStream)": "java.io.DesugarInputStream"
       },
       "amend_library_method": [
+        "public static java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)",
+        "public java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()",
+        "public long java.util.concurrent.TimeUnit#convert(java.time.Duration)",
         "public long java.io.InputStream#transferTo(java.io.OutputStream)"
       ]
     },
@@ -34,8 +43,7 @@
         "java.time.ZonedDateTime java.util.GregorianCalendar#toZonedDateTime()": "java.util.DesugarGregorianCalendar"
       },
       "wrapper_conversion": [
-        "java.time.Clock",
-        "java.time.temporal.ChronoUnit"
+        "java.time.Clock"
       ],
       "custom_conversion": {
         "java.time.Duration": "java.time.TimeConversions",
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 068f2ec..f578416 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -333,7 +333,7 @@
       if (options.isGeneratingClassFiles()) {
         new CfApplicationWriter(appView, marker).write(options.getClassFileConsumer(), inputApp);
       } else {
-        new ApplicationWriter(appView, marker).write(executor, inputApp);
+        ApplicationWriter.create(appView, marker).write(executor, inputApp);
       }
       options.printWarnings();
     } catch (ExecutionException e) {
@@ -428,7 +428,7 @@
     ConvertedCfFiles convertedCfFiles = new ConvertedCfFiles();
     new GenericSignatureRewriter(appView).run(appView.appInfo().classes(), executor);
     new KotlinMetadataRewriter(appView).runForD8(executor);
-    new ApplicationWriter(appView, marker, convertedCfFiles).write(executor);
+    ApplicationWriter.create(appView, marker, convertedCfFiles).write(executor);
     AndroidApp.Builder builder = AndroidApp.builder(inputApp);
     builder.getProgramResourceProviders().clear();
     builder.addProgramResourceProvider(convertedCfFiles);
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 6ef6c416..71898e2 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -217,7 +217,7 @@
       if (options.isGeneratingClassFiles()) {
         new CfApplicationWriter(appView, marker).write(options.getClassFileConsumer(), inputApp);
       } else {
-        new ApplicationWriter(appView, marker).write(executorService, inputApp);
+        ApplicationWriter.create(appView, marker).write(executorService, inputApp);
       }
     } catch (IOException e) {
       throw new RuntimeException("Cannot write application", e);
diff --git a/src/main/java/com/android/tools/r8/bisect/Bisect.java b/src/main/java/com/android/tools/r8/bisect/Bisect.java
index c7547a8..8a196d9 100644
--- a/src/main/java/com/android/tools/r8/bisect/Bisect.java
+++ b/src/main/java/com/android/tools/r8/bisect/Bisect.java
@@ -187,7 +187,7 @@
     StringConsumer proguardMapConsumer = options.proguardMapConsumer;
     AndroidAppConsumers compatSink = new AndroidAppConsumers(options);
     ApplicationWriter writer =
-        new ApplicationWriter(
+        ApplicationWriter.create(
             AppView.createForD8(
                 AppInfo.createInitialAppInfo(app, GlobalSyntheticsStrategy.forNonSynthesizing())),
             null);
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index 7db4fbd..10acb93 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -244,19 +244,27 @@
   private AndroidApiLevel validateOrComputeMinApiLevel(
       AndroidApiLevel computedMinApiLevel, DexReader dexReader) {
     DexVersion version = dexReader.getDexVersion();
+    if (!options.testing.dexContainerExperiment
+        && version.getIntValue() == InternalOptions.EXPERIMENTAL_DEX_VERSION) {
+      throwIncompatibleDexVersionAndMinApi(version);
+    }
     if (options.getMinApiLevel() == AndroidApiLevel.getDefault()) {
       computedMinApiLevel = computedMinApiLevel.max(AndroidApiLevel.getMinAndroidApiLevel(version));
     } else if (!version.matchesApiLevel(options.getMinApiLevel())) {
-      throw new CompilationError(
-          "Dex file with version '"
-              + version.getIntValue()
-              + "' cannot be used with min sdk level '"
-              + options.getMinApiLevel()
-              + "'.");
+      throwIncompatibleDexVersionAndMinApi(version);
     }
     return computedMinApiLevel;
   }
 
+  private void throwIncompatibleDexVersionAndMinApi(DexVersion version) {
+    throw new CompilationError(
+        "Dex file with version '"
+            + version.getIntValue()
+            + "' cannot be used with min sdk level '"
+            + options.getMinApiLevel()
+            + "'.");
+  }
+
   private void readProguardMap(
       StringResource map,
       DexApplication.Builder<?> builder,
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index 96b00bf..5f0d225 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -95,6 +95,7 @@
 
   public final AppView<?> appView;
   public final InternalOptions options;
+
   private final CodeToKeep desugaredLibraryCodeToKeep;
   private final Predicate<DexType> isTypeMissing;
   private final Optional<Marker> currentMarker;
@@ -174,11 +175,7 @@
     }
   }
 
-  public ApplicationWriter(AppView<?> appView, Marker marker) {
-    this(appView, marker, null);
-  }
-
-  public ApplicationWriter(AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+  protected ApplicationWriter(AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
     this.appView = appView;
     this.options = appView.options();
     this.desugaredLibraryCodeToKeep = CodeToKeep.createCodeToKeep(appView);
@@ -189,10 +186,27 @@
     this.previousMarkers = appView.dexItemFactory().extractMarkers();
   }
 
+  public static ApplicationWriter create(AppView<?> appView, Marker marker) {
+    return ApplicationWriter.create(appView, marker, null);
+  }
+
+  public static ApplicationWriter create(
+      AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+    if (appView.options().testing.dexContainerExperiment) {
+      return new ApplicationWriterExperimental(appView, marker, consumer);
+    } else {
+      return new ApplicationWriter(appView, marker, consumer);
+    }
+  }
+
   private NamingLens getNamingLens() {
     return appView.getNamingLens();
   }
 
+  public CodeToKeep getDesugaredLibraryCodeToKeep() {
+    return desugaredLibraryCodeToKeep;
+  }
+
   private List<VirtualFile> distribute(ExecutorService executorService)
       throws ExecutionException, IOException {
     Collection<DexProgramClass> classes = appView.appInfo().classes();
@@ -283,6 +297,52 @@
     write(executorService, null);
   }
 
+  protected Timing rewriteJumboStringsAndComputeDebugRepresentation(
+      VirtualFile virtualFile, List<LazyDexString> lazyDexStrings) {
+    Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+    computeOffsetMappingAndRewriteJumboStrings(virtualFile, lazyDexStrings, fileTiming);
+    DebugRepresentation.computeForFile(appView, virtualFile);
+    fileTiming.end();
+    return fileTiming;
+  }
+
+  protected Collection<Timing> rewriteJumboStringsAndComputeDebugRepresentation(
+      ExecutorService executorService,
+      List<VirtualFile> virtualFiles,
+      List<LazyDexString> lazyDexStrings)
+      throws ExecutionException {
+    return ThreadUtils.processItemsWithResults(
+        virtualFiles,
+        virtualFile ->
+            rewriteJumboStringsAndComputeDebugRepresentation(virtualFile, lazyDexStrings),
+        executorService);
+  }
+
+  protected void writeVirtualFiles(
+      ExecutorService executorService,
+      List<VirtualFile> virtualFiles,
+      List<DexString> forcedStrings,
+      Timing timing)
+      throws ExecutionException {
+    TimingMerger merger =
+        timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
+    Collection<Timing> timings =
+        ThreadUtils.processItemsWithResults(
+            virtualFiles,
+            virtualFile -> {
+              Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+              writeVirtualFile(virtualFile, fileTiming, forcedStrings);
+              fileTiming.end();
+              return fileTiming;
+            },
+            executorService);
+    merger.add(timings);
+    merger.end();
+    if (globalsSyntheticsConsumer != null) {
+      globalsSyntheticsConsumer.finished(appView);
+    }
+  }
+
   public void write(ExecutorService executorService, AndroidApp inputApp)
       throws IOException, ExecutionException {
     Timing timing = appView.appInfo().app().timing;
@@ -337,17 +397,8 @@
         TimingMerger merger =
             timing.beginMerger("Pre-write phase", ThreadUtils.getNumberOfThreads(executorService));
         Collection<Timing> timings =
-            ThreadUtils.processItemsWithResults(
-                virtualFiles,
-                virtualFile -> {
-                  Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
-                  computeOffsetMappingAndRewriteJumboStrings(
-                      virtualFile, lazyDexStrings, fileTiming);
-                  DebugRepresentation.computeForFile(appView, virtualFile);
-                  fileTiming.end();
-                  return fileTiming;
-                },
-                executorService);
+            rewriteJumboStringsAndComputeDebugRepresentation(
+                executorService, virtualFiles, lazyDexStrings);
         merger.add(timings);
         merger.end();
       }
@@ -370,26 +421,8 @@
       }
       timing.end();
 
-      {
-        // Write the actual dex code.
-        TimingMerger merger =
-            timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
-        Collection<Timing> timings =
-            ThreadUtils.processItemsWithResults(
-                virtualFiles,
-                virtualFile -> {
-                  Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
-                  writeVirtualFile(virtualFile, fileTiming, forcedStrings);
-                  fileTiming.end();
-                  return fileTiming;
-                },
-                executorService);
-        merger.add(timings);
-        merger.end();
-        if (globalsSyntheticsConsumer != null) {
-          globalsSyntheticsConsumer.finished(appView);
-        }
-      }
+      // Write the actual dex code.
+      writeVirtualFiles(executorService, virtualFiles, forcedStrings, timing);
 
       // A consumer can manage the generated keep rules.
       if (options.desugaredLibraryKeepRuleConsumer != null && !desugaredLibraryCodeToKeep.isNop()) {
@@ -881,7 +914,7 @@
    * <p>If run multiple times on a class, the lowest index that is required to be a JumboString will
    * be used.
    */
-  private void rewriteCodeWithJumboStrings(
+  protected void rewriteCodeWithJumboStrings(
       ObjectToOffsetMapping mapping,
       Collection<DexProgramClass> classes,
       DexApplication application) {
@@ -923,7 +956,7 @@
     // Collect the non-fixed sections.
     timing.time("collect", fileWriter::collect);
     // Generate and write the bytes.
-    return timing.time("generate", fileWriter::generate);
+    return timing.time("generate", () -> fileWriter.generate());
   }
 
   private static String mapMainDexListName(DexType type, NamingLens namingLens) {
@@ -956,7 +989,7 @@
     }
   }
 
-  private void printItemUseInfo(VirtualFile virtualFile) {
+  protected void printItemUseInfo(VirtualFile virtualFile) {
     if (options.testing.calculateItemUseCountInDex) {
       synchronized (System.out) {
         System.out.print("\"Item\"");
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java
new file mode 100644
index 0000000..021a904
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java
@@ -0,0 +1,209 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.dex;
+
+import com.android.tools.r8.ByteBufferProvider;
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.DexFilePerClassFileConsumer;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.ProgramConsumer;
+import com.android.tools.r8.debuginfo.DebugRepresentation;
+import com.android.tools.r8.dex.FileWriter.ByteBufferResult;
+import com.android.tools.r8.dex.FileWriter.DexContainerSection;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.ObjectToOffsetMapping;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.Timing.TimingMerger;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+class ApplicationWriterExperimental extends ApplicationWriter {
+  protected ApplicationWriterExperimental(
+      AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+    super(appView, marker, consumer);
+  }
+
+  @Override
+  protected Collection<Timing> rewriteJumboStringsAndComputeDebugRepresentation(
+      ExecutorService executorService,
+      List<VirtualFile> virtualFiles,
+      List<LazyDexString> lazyDexStrings)
+      throws ExecutionException {
+    // Collect strings from all virtual files into the last DEX section.
+    VirtualFile lastFile = virtualFiles.get(virtualFiles.size() - 1);
+    List<VirtualFile> allExceptLastFile = virtualFiles.subList(0, virtualFiles.size() - 1);
+    for (VirtualFile virtualFile : allExceptLastFile) {
+      lastFile.indexedItems.addStrings(virtualFile.indexedItems.getStrings());
+    }
+    Collection<Timing> timings = new ArrayList<>(virtualFiles.size());
+    // Compute string layout and handle jumbo strings for the last DEX section.
+    timings.add(rewriteJumboStringsAndComputeDebugRepresentation(lastFile, lazyDexStrings));
+    // Handle jumbo strings for the remaining DEX sections using the string ids in the last DEX
+    // section.
+    timings.addAll(
+        ThreadUtils.processItemsWithResults(
+            allExceptLastFile,
+            virtualFile ->
+                rewriteJumboStringsAndComputeDebugRepresentationWithExternalStringIds(
+                    virtualFile, lazyDexStrings, lastFile.getObjectMapping()),
+            executorService));
+    return timings;
+  }
+
+  private Timing rewriteJumboStringsAndComputeDebugRepresentationWithExternalStringIds(
+      VirtualFile virtualFile, List<LazyDexString> lazyDexStrings, ObjectToOffsetMapping mapping) {
+    Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+    computeOffsetMappingAndRewriteJumboStringsWithExternalStringIds(
+        virtualFile, lazyDexStrings, fileTiming, mapping);
+    DebugRepresentation.computeForFile(appView, virtualFile);
+    fileTiming.end();
+    return fileTiming;
+  }
+
+  private void computeOffsetMappingAndRewriteJumboStringsWithExternalStringIds(
+      VirtualFile virtualFile,
+      List<LazyDexString> lazyDexStrings,
+      Timing timing,
+      ObjectToOffsetMapping mapping) {
+    if (virtualFile.isEmpty()) {
+      return;
+    }
+    timing.begin("Compute object offset mapping");
+    virtualFile.computeMapping(appView, lazyDexStrings.size(), timing, mapping);
+    timing.end();
+    timing.begin("Rewrite jumbo strings");
+    rewriteCodeWithJumboStrings(
+        virtualFile.getObjectMapping(), virtualFile.classes(), appView.appInfo().app());
+    timing.end();
+  }
+
+  @Override
+  protected void writeVirtualFiles(
+      ExecutorService executorService,
+      List<VirtualFile> virtualFiles,
+      List<DexString> forcedStrings,
+      Timing timing)
+      throws ExecutionException {
+    TimingMerger merger =
+        timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
+    Collection<Timing> timings;
+    // TODO(b/249922554): Current limitations for the experimental flag.
+    assert globalsSyntheticsConsumer == null;
+    assert programConsumer == null;
+    virtualFiles.forEach(
+        virtualFile -> {
+          assert virtualFile.getPrimaryClassDescriptor() == null;
+          assert virtualFile.getFeatureSplit() == null;
+        });
+
+    ProgramConsumer consumer = options.getDexIndexedConsumer();
+    ByteBufferProvider byteBufferProvider = options.getDexIndexedConsumer();
+    DexOutputBuffer dexOutputBuffer = new DexOutputBuffer(byteBufferProvider);
+    byte[] tempForAssertions = new byte[] {};
+
+    int offset = 0;
+    timings = new ArrayList<>();
+    List<DexContainerSection> sections = new ArrayList<>();
+
+    // TODO(b/249922554): Write in parallel.
+    for (int i = 0; i < virtualFiles.size(); i++) {
+      VirtualFile virtualFile = virtualFiles.get(i);
+      Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+      assert forcedStrings.size() == 0;
+      DexContainerSection section =
+          writeVirtualFileSection(
+              virtualFile,
+              fileTiming,
+              forcedStrings,
+              offset,
+              dexOutputBuffer,
+              i == virtualFiles.size() - 1);
+
+      if (InternalOptions.assertionsEnabled()) {
+        // Check that writing did not modify already written sections.
+        byte[] outputSoFar = dexOutputBuffer.asArray();
+        for (int j = 0; j < offset; j++) {
+          assert tempForAssertions[j] == outputSoFar[j];
+        }
+        // Copy written sections including the one just written
+        tempForAssertions = new byte[section.getLayout().getEndOfFile()];
+        for (int j = 0; j < section.getLayout().getEndOfFile(); j++) {
+          tempForAssertions[j] = outputSoFar[j];
+        }
+      }
+
+      offset = section.getLayout().getEndOfFile();
+      sections.add(section);
+      fileTiming.end();
+      timings.add(fileTiming);
+    }
+    merger.add(timings);
+    merger.end();
+
+    ByteBufferResult result =
+        new ByteBufferResult(
+            dexOutputBuffer.stealByteBuffer(),
+            sections.get(sections.size() - 1).getLayout().getEndOfFile());
+    ByteDataView data =
+        new ByteDataView(result.buffer.array(), result.buffer.arrayOffset(), result.length);
+    // TODO(b/249922554): Add timing of passing to consumer.
+    if (consumer instanceof DexFilePerClassFileConsumer) {
+      assert false;
+    } else {
+      ((DexIndexedConsumer) consumer).accept(0, data, Sets.newIdentityHashSet(), options.reporter);
+    }
+  }
+
+  private DexContainerSection writeVirtualFileSection(
+      VirtualFile virtualFile,
+      Timing timing,
+      List<DexString> forcedStrings,
+      int offset,
+      DexOutputBuffer outputBuffer,
+      boolean last) {
+    if (virtualFile.isEmpty()) {
+      return null;
+    }
+    printItemUseInfo(virtualFile);
+
+    timing.begin("Reindex for lazy strings");
+    ObjectToOffsetMapping objectMapping = virtualFile.getObjectMapping();
+    objectMapping.computeAndReindexForLazyDexStrings(forcedStrings);
+    timing.end();
+
+    timing.begin("Write bytes");
+    DexContainerSection section =
+        writeDexFile(objectMapping, outputBuffer, virtualFile, timing, offset, last);
+    timing.end();
+    return section;
+  }
+
+  protected DexContainerSection writeDexFile(
+      ObjectToOffsetMapping objectMapping,
+      DexOutputBuffer dexOutputBuffer,
+      VirtualFile virtualFile,
+      Timing timing,
+      int offset,
+      boolean includeStringData) {
+    FileWriter fileWriter =
+        new FileWriter(
+            appView,
+            dexOutputBuffer,
+            objectMapping,
+            getDesugaredLibraryCodeToKeep(),
+            virtualFile,
+            includeStringData);
+    // Collect the non-fixed sections.
+    timing.time("collect", fileWriter::collect);
+    // Generate and write the bytes.
+    return timing.time("generate", () -> fileWriter.generate(offset));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
index 08f8cad..e552456 100644
--- a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
+++ b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
@@ -39,7 +39,7 @@
     if (byteBuffer.remaining() < bytes) {
       int newSize = byteBuffer.capacity() + Math.max(byteBuffer.capacity(), bytes * 2);
       CompatByteBuffer newBuffer = allocateByteBuffer(newSize);
-      System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, position());
+      System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, byteBuffer.capacity());
       newBuffer.position(byteBuffer.position());
       freeByteBuffer(byteBuffer);
       byteBuffer = newBuffer;
@@ -126,6 +126,14 @@
     byteBuffer.putInt(anInteger);
   }
 
+  public boolean assertZero() {
+    int pos = byteBuffer.position();
+    int i = byteBuffer.getInt();
+    assert i == 0;
+    byteBuffer.position(pos);
+    return true;
+  }
+
   /**
    * Moves the position in the bytebuffer forward until it is aligned.
    *
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index a6f6a52..9ddc2d2 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -84,7 +84,7 @@
     public final CompatByteBuffer buffer;
     public final int length;
 
-    private ByteBufferResult(CompatByteBuffer buffer, int length) {
+    protected ByteBufferResult(CompatByteBuffer buffer, int length) {
       this.buffer = buffer;
       this.length = length;
     }
@@ -98,6 +98,7 @@
   private final MixedSectionOffsets mixedSectionOffsets;
   private final CodeToKeep desugaredLibraryCodeToKeep;
   private final VirtualFile virtualFile;
+  private final boolean includeStringData;
 
   public FileWriter(
       AppView<?> appView,
@@ -105,20 +106,41 @@
       ObjectToOffsetMapping mapping,
       CodeToKeep desugaredLibraryCodeToKeep,
       VirtualFile virtualFile) {
+    this(
+        appView,
+        new DexOutputBuffer(provider),
+        mapping,
+        desugaredLibraryCodeToKeep,
+        virtualFile,
+        true);
+  }
+
+  public FileWriter(
+      AppView<?> appView,
+      DexOutputBuffer dexOutputBuffer,
+      ObjectToOffsetMapping mapping,
+      CodeToKeep desugaredLibraryCodeToKeep,
+      VirtualFile virtualFile,
+      boolean includeStringData) {
     this.appView = appView;
     this.graphLens = appView.graphLens();
     this.mapping = mapping;
     this.options = appView.options();
-    this.dest = new DexOutputBuffer(provider);
+    this.dest = dexOutputBuffer;
     this.mixedSectionOffsets = new MixedSectionOffsets(options);
     this.desugaredLibraryCodeToKeep = desugaredLibraryCodeToKeep;
     this.virtualFile = virtualFile;
+    this.includeStringData = includeStringData;
   }
 
   private NamingLens getNamingLens() {
     return appView.getNamingLens();
   }
 
+  public MixedSectionOffsets getMixedSectionOffsets() {
+    return mixedSectionOffsets;
+  }
+
   public static void writeEncodedAnnotation(
       DexEncodedAnnotation annotation, DexOutputBuffer dest, ObjectToOffsetMapping mapping) {
     if (Log.ENABLED) {
@@ -158,14 +180,43 @@
     return this;
   }
 
+  public static class DexContainerSection {
+    private final FileWriter writer;
+    private final DexOutputBuffer buffer;
+    private final Layout layout;
+
+    public DexContainerSection(FileWriter writer, DexOutputBuffer buffer, Layout layout) {
+      this.writer = writer;
+      this.buffer = buffer;
+      this.layout = layout;
+    }
+
+    public FileWriter getFileWriter() {
+      return writer;
+    }
+
+    public DexOutputBuffer getBuffer() {
+      return buffer;
+    }
+
+    public Layout getLayout() {
+      return layout;
+    }
+  }
+
   public ByteBufferResult generate() {
+    DexContainerSection res = generate(0);
+    return new ByteBufferResult(res.getBuffer().stealByteBuffer(), res.getLayout().getEndOfFile());
+  }
+
+  public DexContainerSection generate(int offset) {
     // Check restrictions on interface methods.
     checkInterfaceMethods();
 
     // Check restriction on the names of fields, methods and classes
     assert verifyNames();
 
-    Layout layout = Layout.from(mapping);
+    Layout layout = Layout.from(mapping, offset, includeStringData);
     layout.setCodesOffset(layout.dataSectionOffset);
 
     // Sort the codes first, as their order might impact size due to alignment constraints.
@@ -205,10 +256,14 @@
         mixedSectionLayoutStrategy.getTypeListLayout(),
         layout::alreadySetOffset,
         this::writeTypeList);
-    writeItems(
-        mixedSectionLayoutStrategy.getStringDataLayout(),
-        layout::setStringDataOffsets,
-        this::writeStringData);
+    if (includeStringData) {
+      writeItems(
+          mixedSectionLayoutStrategy.getStringDataLayout(),
+          layout::setStringDataOffsets,
+          this::writeStringData);
+    } else {
+      layout.stringDataOffsets = 0; // Empty string data section.
+    }
     writeItems(
         mixedSectionLayoutStrategy.getAnnotationLayout(),
         layout::setAnnotationsOffset,
@@ -243,8 +298,12 @@
     layout.setEndOfFile(dest.position());
 
     // Now that we have all mixedSectionOffsets, lets write the indexed items.
-    dest.moveTo(Constants.TYPE_HEADER_ITEM_SIZE);
-    writeFixedSectionItems(mapping.getStrings(), layout.stringIdsOffset, this::writeStringItem);
+    dest.moveTo(layout.headerOffset + Constants.TYPE_HEADER_ITEM_SIZE);
+    if (includeStringData) {
+      writeFixedSectionItems(mapping.getStrings(), layout.stringIdsOffset, this::writeStringItem);
+    } else {
+      assert layout.stringIdsOffset == layout.typeIdsOffset;
+    }
     writeFixedSectionItems(mapping.getTypes(), layout.typeIdsOffset, this::writeTypeItem);
     writeFixedSectionItems(mapping.getProtos(), layout.protoIdsOffset, this::writeProtoItem);
     writeFixedSectionItems(mapping.getFields(), layout.fieldIdsOffset, this::writeFieldItem);
@@ -260,7 +319,7 @@
     writeChecksum(layout);
 
     // Wrap backing buffer with actual length.
-    return new ByteBufferResult(dest.stealByteBuffer(), layout.getEndOfFile());
+    return new DexContainerSection(this, dest, layout);
   }
 
   private void checkInterfaceMethods() {
@@ -759,8 +818,11 @@
         mixedSectionOffsets.getDebugInfos().size());
     size += writeMapItem(Constants.TYPE_TYPE_LIST, layout.getTypeListsOffset(),
         mixedSectionOffsets.getTypeLists().size());
-    size += writeMapItem(Constants.TYPE_STRING_DATA_ITEM, layout.getStringDataOffsets(),
-        mixedSectionOffsets.getStringData().size());
+    size +=
+        writeMapItem(
+            Constants.TYPE_STRING_DATA_ITEM,
+            layout.getStringDataOffsets(),
+            layout.getStringDataOffsets() == 0 ? 0 : mixedSectionOffsets.getStringData().size());
     size += writeMapItem(Constants.TYPE_ANNOTATION_ITEM, layout.getAnnotationsOffset(),
         mixedSectionOffsets.getAnnotations().size());
     size += writeMapItem(Constants.TYPE_CLASS_DATA_ITEM, layout.getClassDataOffset(),
@@ -784,16 +846,22 @@
     dest.forward(size * Constants.TYPE_MAP_LIST_ITEM_SIZE);
   }
 
+  private byte[] dexVersionBytes() {
+    if (options.testing.dexContainerExperiment) {
+      return DexVersion.V40.getBytes();
+    }
+    return options.testing.forceDexVersionBytes != null
+        ? options.testing.forceDexVersionBytes
+        : DexVersion.getDexVersion(options.getMinApiLevel()).getBytes();
+  }
+
   private void writeHeader(Layout layout) {
-    dest.moveTo(0);
+    dest.moveTo(layout.headerOffset);
     dest.putBytes(Constants.DEX_FILE_MAGIC_PREFIX);
-    dest.putBytes(
-        options.testing.forceDexVersionBytes != null
-            ? options.testing.forceDexVersionBytes
-            : DexVersion.getDexVersion(options.getMinApiLevel()).getBytes());
+    dest.putBytes(dexVersionBytes());
     dest.putByte(Constants.DEX_FILE_MAGIC_SUFFIX);
     // Leave out checksum and signature for now.
-    dest.moveTo(Constants.FILE_SIZE_OFFSET);
+    dest.moveTo(layout.headerOffset + Constants.FILE_SIZE_OFFSET);
     dest.putInt(layout.getEndOfFile());
     dest.putInt(Constants.TYPE_HEADER_ITEM_SIZE);
     dest.putInt(Constants.ENDIAN_CONSTANT);
@@ -826,9 +894,11 @@
   private void writeSignature(Layout layout) {
     try {
       MessageDigest md = MessageDigest.getInstance("SHA-1");
-      md.update(dest.asArray(), Constants.FILE_SIZE_OFFSET,
-          layout.getEndOfFile() - Constants.FILE_SIZE_OFFSET);
-      md.digest(dest.asArray(), Constants.SIGNATURE_OFFSET, 20);
+      md.update(
+          dest.asArray(),
+          layout.headerOffset + Constants.FILE_SIZE_OFFSET,
+          layout.getEndOfFile() - layout.headerOffset - Constants.FILE_SIZE_OFFSET);
+      md.digest(dest.asArray(), layout.headerOffset + Constants.SIGNATURE_OFFSET, 20);
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
@@ -836,9 +906,11 @@
 
   private void writeChecksum(Layout layout) {
     Adler32 adler = new Adler32();
-    adler.update(dest.asArray(), Constants.SIGNATURE_OFFSET,
-        layout.getEndOfFile() - Constants.SIGNATURE_OFFSET);
-    dest.moveTo(Constants.CHECKSUM_OFFSET);
+    adler.update(
+        dest.asArray(),
+        layout.headerOffset + Constants.SIGNATURE_OFFSET,
+        layout.getEndOfFile() - layout.headerOffset - Constants.SIGNATURE_OFFSET);
+    dest.moveTo(layout.headerOffset + Constants.CHECKSUM_OFFSET);
     dest.putInt((int) adler.getValue());
   }
 
@@ -847,11 +919,12 @@
     return (value + mask) & ~mask;
   }
 
-  private static class Layout {
+  public static class Layout {
 
     private static final int NOT_SET = -1;
 
     // Fixed size constant pool sections
+    final int headerOffset;
     final int stringIdsOffset;
     final int typeIdsOffset;
     final int protoIdsOffset;
@@ -878,6 +951,7 @@
     private int endOfFile = NOT_SET;
 
     private Layout(
+        int headerOffset,
         int stringIdsOffset,
         int typeIdsOffset,
         int protoIdsOffset,
@@ -887,6 +961,7 @@
         int callSiteIdsOffset,
         int methodHandleIdsOffset,
         int dataSectionOffset) {
+      this.headerOffset = headerOffset;
       this.stringIdsOffset = stringIdsOffset;
       this.typeIdsOffset = typeIdsOffset;
       this.protoIdsOffset = protoIdsOffset;
@@ -907,10 +982,17 @@
     }
 
     static Layout from(ObjectToOffsetMapping mapping) {
-      int offset = 0;
+      return from(mapping, 0, true);
+    }
+
+    static Layout from(ObjectToOffsetMapping mapping, int offset, boolean includeStringData) {
       return new Layout(
-          offset = Constants.TYPE_HEADER_ITEM_SIZE,
-          offset += mapping.getStrings().size() * Constants.TYPE_STRING_ID_ITEM_SIZE,
+          offset,
+          offset += Constants.TYPE_HEADER_ITEM_SIZE,
+          offset +=
+              includeStringData
+                  ? mapping.getStrings().size() * Constants.TYPE_STRING_ID_ITEM_SIZE
+                  : 0,
           offset += mapping.getTypes().size() * Constants.TYPE_TYPE_ID_ITEM_SIZE,
           offset += mapping.getProtos().size() * Constants.TYPE_PROTO_ID_ITEM_SIZE,
           offset += mapping.getFields().size() * Constants.TYPE_FIELD_ID_ITEM_SIZE,
@@ -1049,6 +1131,95 @@
     public void setEndOfFile(int endOfFile) {
       this.endOfFile = endOfFile;
     }
+
+    @Override
+    public String toString() {
+      StringBuilder builder = new StringBuilder();
+      if (false) {
+        builder.append("headerOffset: ").append(headerOffset).append("\n");
+        builder.append("stringIdsOffset: ").append(stringIdsOffset).append("\n");
+        builder.append("typeIdsOffset: ").append(typeIdsOffset).append("\n");
+        builder.append("protoIdsOffset: ").append(protoIdsOffset).append("\n");
+        builder.append("fieldIdsOffset: ").append(fieldIdsOffset).append("\n");
+        builder.append("methodIdsOffset: ").append(methodIdsOffset).append("\n");
+        builder.append("classDefsOffset: ").append(classDefsOffset).append("\n");
+        builder.append("callSiteIdsOffset: ").append(callSiteIdsOffset).append("\n");
+        builder.append("methodHandleIdsOffset: ").append(methodHandleIdsOffset).append("\n");
+        builder.append("dataSectionOffset: ").append(dataSectionOffset).append("\n");
+
+        // Mixed size sections
+        builder.append("codesOffset: ").append(codesOffset).append("\n");
+        builder.append("debugInfosOffset: ").append(debugInfosOffset).append("\n");
+
+        builder.append("typeListsOffset: ").append(typeListsOffset).append("\n");
+        builder.append("stringDataOffsets: ").append(stringDataOffsets).append("\n");
+        builder.append("annotationsOffset: ").append(annotationsOffset).append("\n");
+        builder.append("annotationSetsOffset: ").append(annotationSetsOffset).append("\n");
+        builder
+            .append("annotationSetRefListsOffset: ")
+            .append(annotationSetRefListsOffset)
+            .append("\n");
+        builder
+            .append("annotationDirectoriesOffset: ")
+            .append(annotationDirectoriesOffset)
+            .append("\n");
+        builder.append("classDataOffset: ").append(classDataOffset).append("\n");
+        builder.append("encodedArraysOffset: ").append(encodedArraysOffset).append("\n");
+        builder.append("mapOffset: ").append(mapOffset).append("\n");
+        builder.append("endOfFile: ").append(endOfFile).append("\n");
+      } else {
+        builder.append("Header: ").append(stringIdsOffset - headerOffset).append("\n");
+        builder.append("StringIds: ").append(typeIdsOffset - stringIdsOffset).append("\n");
+        builder.append("typeIds: ").append(protoIdsOffset - typeIdsOffset).append("\n");
+        builder.append("protoIds: ").append(fieldIdsOffset - protoIdsOffset).append("\n");
+        builder.append("fieldIds: ").append(methodIdsOffset - fieldIdsOffset).append("\n");
+        builder.append("methodIds: ").append(classDefsOffset - methodIdsOffset).append("\n");
+        builder.append("classDefs: ").append(callSiteIdsOffset - classDefsOffset).append("\n");
+        builder
+            .append("callSiteIds: ")
+            .append(methodHandleIdsOffset - callSiteIdsOffset)
+            .append("\n");
+        builder
+            .append("methodHandleIds: ")
+            .append(dataSectionOffset - methodHandleIdsOffset)
+            .append("\n");
+
+        // Mixed size sections
+        builder.append("code: ").append(debugInfosOffset - codesOffset).append("\n");
+        builder.append("debugInfo: ").append(typeListsOffset - debugInfosOffset).append("\n");
+
+        builder
+            .append("typeList: ")
+            .append(
+                (stringDataOffsets > 0 ? stringDataOffsets : annotationsOffset) - typeListsOffset)
+            .append("\n");
+        builder
+            .append("stringData: ")
+            .append(stringDataOffsets > 0 ? annotationsOffset - stringDataOffsets : 0)
+            .append("\n");
+        builder.append("annotations: ").append(classDataOffset - annotationsOffset).append("\n");
+        builder.append("classData: ").append(encodedArraysOffset - classDataOffset).append("\n");
+        builder
+            .append("encodedArrays: ")
+            .append(mapOffset - annotationSetRefListsOffset)
+            .append("\n");
+        builder
+            .append("annotationSets: ")
+            .append(annotationSetRefListsOffset - annotationSetsOffset)
+            .append("\n");
+        builder
+            .append("annotationSetRefLists: ")
+            .append(annotationDirectoriesOffset - annotationSetRefListsOffset)
+            .append("\n");
+        builder
+            .append("annotationDirectories: ")
+            .append(mapOffset - annotationDirectoriesOffset)
+            .append("\n");
+        builder.append("map: ").append(endOfFile - mapOffset).append("\n");
+        builder.append("endOfFile: ").append(endOfFile).append("\n");
+      }
+      return builder.toString();
+    }
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index f6b057a..436f365 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -203,11 +203,20 @@
       AppView<?> appView,
       int lazyDexStringsCount,
       Timing timing) {
+    computeMapping(appView, lazyDexStringsCount, timing, null);
+  }
+
+  public void computeMapping(
+      AppView<?> appView,
+      int lazyDexStringsCount,
+      Timing timing,
+      ObjectToOffsetMapping sharedMapping) {
     assert transaction.isEmpty();
     assert objectMapping == null;
     objectMapping =
         new ObjectToOffsetMapping(
             appView,
+            sharedMapping,
             transaction.rewriter,
             indexedItems.classes,
             indexedItems.protos,
@@ -663,6 +672,10 @@
       return strings.add(string);
     }
 
+    public boolean addStrings(Collection<DexString> additionalStrings) {
+      return strings.addAll(additionalStrings);
+    }
+
     @Override
     public boolean addProto(DexProto proto) {
       return protos.add(proto);
@@ -691,6 +704,10 @@
     int getNumberOfFields() {
       return fields.size();
     }
+
+    Collection<DexString> getStrings() {
+      return strings;
+    }
   }
 
   public static class IndexedItemTransaction implements IndexedItemCollection {
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
index 6173bef..028617e 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
@@ -53,6 +53,7 @@
 
   public ObjectToOffsetMapping(
       AppView<?> appView,
+      ObjectToOffsetMapping sharedMapping,
       LensCodeRewriterUtils lensCodeRewriter,
       Collection<DexProgramClass> classes,
       Collection<DexProto> protos,
@@ -80,9 +81,14 @@
     this.initClassLens = appView.initClassLens();
     this.lensCodeRewriter = lensCodeRewriter;
     timing.begin("Sort strings");
-    this.strings =
-        createSortedMap(
-            strings, DexString::compareTo, this::setFirstJumboString, lazyDexStringsCount);
+    if (sharedMapping == null) {
+      this.strings =
+          createSortedMap(
+              strings, DexString::compareTo, this::setFirstJumboString, lazyDexStringsCount);
+    } else {
+      this.strings = sharedMapping.strings;
+      this.firstJumboString = sharedMapping.firstJumboString;
+    }
     CompareToVisitor visitor =
         new CompareToVisitorWithStringTable(namingLens, this.strings::getInt);
     timing.end();
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNaming.java b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
index 6083e8b..138e738 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
@@ -18,7 +18,7 @@
 
   abstract class Builder {
 
-    public abstract Builder addMemberEntry(MemberNaming entry, Signature residualSignature);
+    public abstract Builder addMemberEntry(MemberNaming entry);
 
     public abstract ClassNaming build();
 
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
index 93a5666..cbfb5e3 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
@@ -19,6 +19,7 @@
 import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -55,7 +56,7 @@
     }
 
     @Override
-    public ClassNaming.Builder addMemberEntry(MemberNaming entry, Signature residualSignature) {
+    public ClassNaming.Builder addMemberEntry(MemberNaming entry) {
       // Unlike {@link ClassNamingForNameMapper.Builder#addMemberEntry},
       // the key is original signature.
       if (entry.isMethodNaming()) {
@@ -170,32 +171,26 @@
   public MemberNaming lookup(Signature renamedSignature) {
     // As the key is inverted, this looks a lot like
     //   {@link ClassNamingForNameMapper#lookupByOriginalSignature}.
-    if (renamedSignature.kind() == SignatureKind.METHOD) {
-      for (MemberNaming memberNaming : methodMembers.values()) {
-        if (memberNaming.getResidualSignatureInternal().equals(renamedSignature)) {
-          return memberNaming;
-        }
+    Collection<MemberNaming> memberNamings =
+        renamedSignature.kind() == SignatureKind.METHOD
+            ? methodMembers.values()
+            : fieldMembers.values();
+    for (MemberNaming memberNaming : memberNamings) {
+      if (memberNaming.getResidualSignature().equals(renamedSignature)) {
+        return memberNaming;
       }
-      return null;
-    } else {
-      assert renamedSignature.kind() == SignatureKind.FIELD;
-      for (MemberNaming memberNaming : fieldMembers.values()) {
-        if (memberNaming.getResidualSignatureInternal().equals(renamedSignature)) {
-          return memberNaming;
-        }
-      }
-      return null;
     }
+    return null;
   }
 
   @Override
   public MemberNaming lookupByOriginalSignature(Signature original) {
     // As the key is inverted, this looks a lot like {@link ClassNamingForNameMapper#lookup}.
     if (original.kind() == SignatureKind.METHOD) {
-      return methodMembers.get(original);
+      return methodMembers.get(original.asMethodSignature());
     } else {
       assert original.kind() == SignatureKind.FIELD;
-      return fieldMembers.get(original);
+      return fieldMembers.get(original.asFieldSignature());
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 8fb8ae6..0f09fdf 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import static com.android.tools.r8.naming.MappedRangeUtils.addAllInlineFramesUntilOutermostCaller;
+
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
@@ -11,9 +13,11 @@
 import com.android.tools.r8.naming.mappinginformation.OutlineCallsiteMappingInformation;
 import com.android.tools.r8.naming.mappinginformation.RewriteFrameMappingInformation;
 import com.android.tools.r8.utils.ChainableStringConsumer;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -59,11 +63,11 @@
     }
 
     @Override
-    public ClassNaming.Builder addMemberEntry(MemberNaming entry, Signature residualSignature) {
+    public ClassNaming.Builder addMemberEntry(MemberNaming entry) {
       if (entry.isMethodNaming()) {
-        methodMembers.put(residualSignature.asMethodSignature(), entry);
+        methodMembers.put(entry.getResidualSignature().asMethodSignature(), entry);
       } else {
-        fieldMembers.put(residualSignature.asFieldSignature(), entry);
+        fieldMembers.put(entry.getResidualSignature().asFieldSignature(), entry);
         mappedFieldNamingsByName
             .computeIfAbsent(entry.getRenamedName(), ignored -> new ArrayList<>())
             .add(entry);
@@ -218,6 +222,48 @@
     public int hashCode() {
       return mappedRanges.hashCode();
     }
+
+    public List<MappedRangesOfName> partitionOnMethodSignature() {
+      if (mappedRanges.size() <= 1) {
+        return Collections.singletonList(this);
+      }
+      List<MappedRangesOfName> partitionedMappings = new ArrayList<>();
+      int index = 0;
+      List<MappedRange> currentMappedRanges = new ArrayList<>();
+      index = addAllInlineFramesUntilOutermostCaller(mappedRanges, index, currentMappedRanges);
+      // Do a fast check to see if the last one is the same signature as the first one.
+      if (ListUtils.last(currentMappedRanges)
+          .getOriginalSignature()
+          .equals(ListUtils.last(mappedRanges).getOriginalSignature())) {
+        return Collections.singletonList(this);
+      }
+      // Otherwise the signature changes which means we have overloads.
+      while (index < mappedRanges.size()) {
+        List<MappedRange> newMappedRanges = new ArrayList<>();
+        index = addAllInlineFramesUntilOutermostCaller(mappedRanges, index, newMappedRanges);
+        if (!ListUtils.last(currentMappedRanges)
+            .getOriginalSignature()
+            .equals(ListUtils.last(newMappedRanges).getOriginalSignature())) {
+          partitionedMappings.add(new MappedRangesOfName(currentMappedRanges));
+          currentMappedRanges = new ArrayList<>();
+        }
+        currentMappedRanges.addAll(newMappedRanges);
+      }
+      partitionedMappings.add(new MappedRangesOfName(currentMappedRanges));
+      return partitionedMappings;
+    }
+
+    public MemberNaming getMemberNaming(
+        ClassNamingForNameMapper classNamingForNameMapper, boolean hasMultipleResults) {
+      MappedRange lastMappedRange = ListUtils.last(mappedRanges);
+      if (hasMultipleResults) {
+        return null;
+      }
+      MethodSignature signature = lastMappedRange.getResidualSignature();
+      MemberNaming memberNaming = classNamingForNameMapper.methodMembers.get(signature);
+      assert memberNaming != null;
+      return memberNaming;
+    }
   }
 
   static Builder builder(
@@ -425,7 +471,7 @@
     mappedRangesSorted.sort(Comparator.comparingInt(range -> range.sequenceNumber));
     for (MappedRange range : mappedRangesSorted) {
       consumer.accept("    ").accept(range.toString()).accept("\n");
-      for (MappingInformation info : range.additionalMappingInfo) {
+      for (MappingInformation info : range.getAdditionalMappingInformation()) {
         consumer.accept("      # ").accept(info.serialize()).accept("\n");
       }
     }
@@ -499,13 +545,19 @@
 
     private MethodSignature residualSignature = null;
 
+    private boolean hasComputedHashCode = false;
+
     /**
      * The sole purpose of {@link #sequenceNumber} is to preserve the order of members read from a
      * Proguard-map.
      */
     private final int sequenceNumber = getNextSequenceNumber();
 
-    private List<MappingInformation> additionalMappingInfo = EMPTY_MAPPING_INFORMATION;
+    /**
+     * We never emit member namings for methods so mapped ranges has to account for both positional
+     * and referential mapping information.
+     */
+    private List<MappingInformation> additionalMappingInformation = EMPTY_MAPPING_INFORMATION;
 
     MappedRange(
         Range minifiedRange, MethodSignature signature, Range originalRange, String renamedName) {
@@ -522,40 +574,17 @@
 
     public void addMappingInformation(
         MappingInformation info, Consumer<MappingInformation> onProhibitedAddition) {
-      if (additionalMappingInfo == EMPTY_MAPPING_INFORMATION) {
-        additionalMappingInfo = new ArrayList<>();
+      if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+        additionalMappingInformation = new ArrayList<>();
       }
-      for (MappingInformation existing : additionalMappingInfo) {
-        if (!existing.allowOther(info)) {
-          onProhibitedAddition.accept(existing);
-          return;
-        }
-      }
-      additionalMappingInfo.add(info);
+      MappingInformation.addMappingInformation(
+          additionalMappingInformation, info, onProhibitedAddition);
     }
 
-    public boolean isCompilerSynthesized() {
-      for (MappingInformation info : additionalMappingInfo) {
-        if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
-          return true;
-        }
-      }
-      return false;
-    }
-
-    public boolean isOutlineFrame() {
-      for (MappingInformation info : additionalMappingInfo) {
-        if (info.isOutlineMappingInformation()) {
-          return true;
-        }
-      }
-      return false;
-    }
-
-    public <T> List<T> filter(
+    private <T> List<T> filter(
         Predicate<MappingInformation> predicate, Function<MappingInformation, T> mapper) {
       ImmutableList.Builder<T> builder = ImmutableList.builder();
-      for (MappingInformation mappingInformation : additionalMappingInfo) {
+      for (MappingInformation mappingInformation : additionalMappingInformation) {
         if (predicate.test(mappingInformation)) {
           builder.add(mapper.apply(mappingInformation));
         }
@@ -607,20 +636,41 @@
       return signature;
     }
 
-    @Override
-    public boolean hasResidualSignature() {
-      return residualSignature != null;
+    public boolean isCompilerSynthesized() {
+      for (MappingInformation info : additionalMappingInformation) {
+        if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public boolean isOutlineFrame() {
+      for (MappingInformation info : additionalMappingInformation) {
+        if (info.isOutlineMappingInformation()) {
+          return true;
+        }
+      }
+      return false;
     }
 
     @Override
-    public MethodSignature getResidualSignatureInternal() {
-      return residualSignature;
+    public boolean hasResidualSignatureMappingInformation() {
+      return Iterables.any(
+          additionalMappingInformation, MappingInformation::isResidualSignatureMappingInformation);
+    }
+
+    public void setResidualSignatureInternal(MethodSignature signature) {
+      assert !hasComputedHashCode;
+      this.residualSignature = signature;
     }
 
     @Override
-    public void setResidualSignatureInternal(Signature residualSignature) {
-      assert residualSignature.isMethodSignature();
-      this.residualSignature = residualSignature.asMethodSignature();
+    public MethodSignature getResidualSignature() {
+      if (residualSignature != null) {
+        return residualSignature;
+      }
+      return signature.asRenamed(renamedName).asMethodSignature();
     }
 
     public int getLastPositionOfOriginalRange() {
@@ -662,7 +712,8 @@
           && Objects.equals(originalRange, that.originalRange)
           && signature.equals(that.signature)
           && renamedName.equals(that.renamedName)
-          && Objects.equals(residualSignature, that.residualSignature);
+          && Objects.equals(residualSignature, that.residualSignature)
+          && Objects.equals(additionalMappingInformation, that.additionalMappingInformation);
     }
 
     @Override
@@ -673,11 +724,13 @@
       result = 31 * result + signature.hashCode();
       result = 31 * result + renamedName.hashCode();
       result = 31 * result + Objects.hashCode(residualSignature);
+      result = 31 * result + Objects.hashCode(additionalMappingInformation);
+      hasComputedHashCode = true;
       return result;
     }
 
-    public List<MappingInformation> getAdditionalMappingInfo() {
-      return Collections.unmodifiableList(additionalMappingInfo);
+    public List<MappingInformation> getAdditionalMappingInformation() {
+      return Collections.unmodifiableList(additionalMappingInformation);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java b/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
index 5b3e838..cc7f927 100644
--- a/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
+++ b/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.naming;
 
+import static com.android.tools.r8.naming.MappedRangeUtils.addAllInlineFramesUntilOutermostCaller;
+import static com.android.tools.r8.naming.MappedRangeUtils.isInlineMappedRange;
 import static com.android.tools.r8.utils.FunctionUtils.ignoreArgument;
 
 import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
@@ -595,7 +597,8 @@
         // Register mapping information that is dependent on the residual naming to allow updating
         // later on.
         for (MappedRange mappedRange : mappedRangesForThisInterval) {
-          for (MappingInformation mappingInformation : mappedRange.getAdditionalMappingInfo()) {
+          for (MappingInformation mappingInformation :
+              mappedRange.getAdditionalMappingInformation()) {
             if (mappingInformation.isRewriteFrameMappingInformation()) {
               RewriteFrameMappingInformation rewriteFrameMappingInformation =
                   mappingInformation.asRewriteFrameMappingInformation();
@@ -631,16 +634,6 @@
           seenMappedRanges);
     }
 
-    private int addAllInlineFramesUntilOutermostCaller(
-        List<MappedRange> mappedRanges, int index, List<MappedRange> seenMappedRanges) {
-      assert index < mappedRanges.size();
-      while (isInlineMappedRange(mappedRanges, index)) {
-        seenMappedRanges.add(mappedRanges.get(index++));
-      }
-      seenMappedRanges.add(mappedRanges.get(index++));
-      return index;
-    }
-
     private List<MappedRange> composeMappedRangesForMethod(
         List<MappedRange> existingRanges, List<MappedRange> newRanges)
         throws MappingComposeException {
@@ -687,8 +680,8 @@
               new MappedRange(
                   null, lastExistingRange.signature, originalRange.get(), newRange.renamedName);
           composeMappingInformation(
-              newComposedRange.getAdditionalMappingInfo(),
-              lastExistingRange.getAdditionalMappingInfo(),
+              newComposedRange.getAdditionalMappingInformation(),
+              lastExistingRange.getAdditionalMappingInformation(),
               info -> newComposedRange.addMappingInformation(info, ConsumerUtils.emptyConsumer()));
           newComposedRanges.add(newComposedRange);
         } else {
@@ -789,7 +782,7 @@
                           newOriginalRange,
                           lastExistingMappedRange.renamedName);
                   nonExistingMappedRange.setResidualSignatureInternal(
-                      lastExistingRange.getResidualSignatureInternal());
+                      lastExistingRange.getResidualSignature());
                   lastExistingMappedRange = nonExistingMappedRange;
                   existingMappedRanges = Collections.singletonList(nonExistingMappedRange);
                   position += (endOriginalPosition - startOriginalPosition) - 1;
@@ -938,7 +931,7 @@
                 newMappedRange.renamedName);
         List<MappingInformation> mappingInformationToCompose = new ArrayList<>();
         existingMappedRange
-            .getAdditionalMappingInfo()
+            .getAdditionalMappingInformation()
             .forEach(
                 info -> {
                   if (info.isOutlineMappingInformation()) {
@@ -952,7 +945,7 @@
                   }
                 });
         composeMappingInformation(
-            computedRange.getAdditionalMappingInfo(),
+            computedRange.getAdditionalMappingInformation(),
             mappingInformationToCompose,
             info -> computedRange.addMappingInformation(info, ConsumerUtils.emptyConsumer()));
         newComposedRanges.add(computedRange);
@@ -989,16 +982,6 @@
           });
     }
 
-    private boolean isInlineMappedRange(List<MappedRange> mappedRanges, int index) {
-      // We are comparing against the next entry so we need a buffer of one.
-      if (index + 1 >= mappedRanges.size()) {
-        return false;
-      }
-      MappedRange mappedRange = mappedRanges.get(index);
-      return mappedRange.minifiedRange != null
-          && mappedRange.minifiedRange.equals(mappedRanges.get(index + 1).minifiedRange);
-    }
-
     public void write(ChainableStringConsumer consumer) {
       consumer.accept(originalName).accept(" -> ").accept(renamedName).accept(":\n");
       additionalMappingInfo.forEach(info -> consumer.accept("# " + info.serialize()).accept("\n"));
@@ -1018,7 +1001,7 @@
       methodsWithoutPosition.forEach(
           (ignored, mapped) -> {
             consumer.accept(INDENTATION).accept(mapped.toString()).accept("\n");
-            for (MappingInformation info : mapped.getAdditionalMappingInfo()) {
+            for (MappingInformation info : mapped.getAdditionalMappingInformation()) {
               consumer.accept(INDENTATION).accept("# ").accept(info.serialize()).accept("\n");
             }
           });
@@ -1043,7 +1026,7 @@
             .forEach(
                 mappedRange -> {
                   consumer.accept(INDENTATION).accept(mappedRange.toString()).accept("\n");
-                  for (MappingInformation info : mappedRange.getAdditionalMappingInfo()) {
+                  for (MappingInformation info : mappedRange.getAdditionalMappingInformation()) {
                     consumer.accept(INDENTATION).accept("# ").accept(info.serialize()).accept("\n");
                   }
                 });
diff --git a/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java b/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java
new file mode 100644
index 0000000..7dff280
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.naming;
+
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import java.util.List;
+
+public class MappedRangeUtils {
+
+  static int addAllInlineFramesUntilOutermostCaller(
+      List<MappedRange> mappedRanges, int index, List<MappedRange> listToAdd) {
+    assert index < mappedRanges.size();
+    while (isInlineMappedRange(mappedRanges, index)) {
+      listToAdd.add(mappedRanges.get(index++));
+    }
+    listToAdd.add(mappedRanges.get(index++));
+    return index;
+  }
+
+  static boolean isInlineMappedRange(List<MappedRange> mappedRanges, int index) {
+    // We are comparing against the next entry so we need a buffer of one.
+    if (index + 1 >= mappedRanges.size()) {
+      return false;
+    }
+    MappedRange mappedRange = mappedRanges.get(index);
+    return mappedRange.minifiedRange != null
+        && mappedRange.minifiedRange.equals(mappedRanges.get(index + 1).minifiedRange);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java b/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
index 7e7bcd0..77e145b 100644
--- a/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
+++ b/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
@@ -13,19 +13,16 @@
 
   Signature getOriginalSignature();
 
-  boolean hasResidualSignature();
+  boolean hasResidualSignatureMappingInformation();
 
-  Signature getResidualSignatureInternal();
+  Signature getResidualSignature();
 
-  void setResidualSignatureInternal(Signature signature);
-
+  /** Should be removed when R8 emits residual information for alpha renamed signatures. */
+  @Deprecated()
   default Signature computeResidualSignature(Function<String, String> typeNameMapper) {
-    if (hasResidualSignature()) {
-      return getResidualSignatureInternal();
+    if (hasResidualSignatureMappingInformation()) {
+      return getResidualSignature();
     }
-    Signature residualSignature =
-        getOriginalSignature().computeResidualSignature(getRenamedName(), typeNameMapper);
-    setResidualSignatureInternal(residualSignature);
-    return residualSignature;
+    return getOriginalSignature().computeResidualSignature(getRenamedName(), typeNameMapper);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 043bb4c..12606ff 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -13,6 +13,8 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
@@ -21,12 +23,16 @@
 import com.android.tools.r8.utils.CollectionUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.Iterables;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Objects;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import org.objectweb.asm.Type;
 
@@ -37,6 +43,9 @@
  */
 public class MemberNaming implements MappingWithResidualInfo {
 
+  private static final List<ReferentialMappingInformation> EMPTY_MAPPING_INFORMATION =
+      Collections.emptyList();
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -45,55 +54,41 @@
     if (!(o instanceof MemberNaming)) {
       return false;
     }
-
     MemberNaming that = (MemberNaming) o;
-    return signature.equals(that.signature)
-        && renamedName.equals(that.renamedName)
-        && Objects.equals(residualSignature, that.residualSignature);
+    return signature.equals(that.signature) && residualSignature.equals(that.residualSignature);
   }
 
   @Override
   public int hashCode() {
     int result = signature.hashCode();
-    result = 31 * result + renamedName.hashCode();
-    result = 31 * result + Objects.hashCode(residualSignature);
+    result = 31 * result + residualSignature.hashCode();
     return result;
   }
 
   /** Original signature of the member. */
   private final Signature signature;
   /** Residual signature where types and names could be changed. */
-  private Signature residualSignature = null;
-  /**
-   * Renamed name in the mapping file. This value will always be present even if the residual
-   * signature is not.
-   */
-  private final String renamedName;
+  private final Signature residualSignature;
   /** Position of the member in the file. */
   private final Position position;
 
-  public MemberNaming(Signature signature, String renamedName) {
-    this(signature, renamedName, Position.UNKNOWN);
-  }
+  private List<ReferentialMappingInformation> additionalMappingInformation =
+      EMPTY_MAPPING_INFORMATION;
 
   public MemberNaming(Signature signature, Signature residualSignature) {
-    this(signature, residualSignature.getName(), Position.UNKNOWN);
-    this.residualSignature = residualSignature;
+    this(signature, residualSignature, Position.UNKNOWN);
   }
 
-  public MemberNaming(Signature signature, String renamedName, Position position) {
+  public MemberNaming(Signature signature, Signature residualSignature, Position position) {
     this.signature = signature;
-    this.renamedName = renamedName;
+    this.residualSignature = residualSignature;
     this.position = position;
   }
 
   /** This is used internally in google3. */
   @Deprecated
   public Signature getRenamedSignature() {
-    if (residualSignature != null) {
-      return residualSignature;
-    }
-    return getOriginalSignature().asRenamed(renamedName);
+    return residualSignature;
   }
 
   @Override
@@ -106,13 +101,14 @@
   }
 
   @Override
-  public boolean hasResidualSignature() {
-    return residualSignature != null;
+  public boolean hasResidualSignatureMappingInformation() {
+    return Iterables.any(
+        additionalMappingInformation, MappingInformation::isResidualSignatureMappingInformation);
   }
 
   @Override
   public String getRenamedName() {
-    return renamedName;
+    return residualSignature.getName();
   }
 
   public boolean isMethodNaming() {
@@ -129,17 +125,50 @@
 
   @Override
   public String toString() {
-    return signature.toString() + " -> " + renamedName;
+    return signature.toString() + " -> " + residualSignature.getName();
   }
 
   @Override
-  public Signature getResidualSignatureInternal() {
+  public Signature getResidualSignature() {
     return residualSignature;
   }
 
-  @Override
-  public void setResidualSignatureInternal(Signature signature) {
-    this.residualSignature = signature;
+  public void addMappingInformation(
+      ReferentialMappingInformation info, Consumer<MappingInformation> onProhibitedAddition) {
+    if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+      additionalMappingInformation = new ArrayList<>();
+    }
+    MappingInformation.addMappingInformation(
+        additionalMappingInformation, info, onProhibitedAddition);
+  }
+
+  void addAllMappingInformationInternal(List<ReferentialMappingInformation> otherInfo) {
+    if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+      additionalMappingInformation = new ArrayList<>();
+    }
+    additionalMappingInformation.addAll(otherInfo);
+  }
+
+  public boolean isCompilerSynthesized() {
+    for (MappingInformation info : additionalMappingInformation) {
+      if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public boolean isOutlineFrame() {
+    for (MappingInformation info : additionalMappingInformation) {
+      if (info.isOutlineMappingInformation()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public List<ReferentialMappingInformation> getAdditionalMappingInformation() {
+    return additionalMappingInformation;
   }
 
   public abstract static class Signature {
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
index 80cc8e6..cd8bd3f 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
@@ -12,11 +12,15 @@
 import com.android.tools.r8.naming.PositionRangeAllocator.NonCardinalPositionRangeAllocator;
 import com.android.tools.r8.naming.mappinginformation.MapVersionMappingInformation;
 import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics;
+import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation;
+import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualFieldSignatureMappingInformation;
 import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualMethodSignatureMappingInformation;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.BooleanBox;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.IdentifierUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -334,14 +338,20 @@
   private void parseMemberMappings(
       ProguardMap.Builder mapBuilder, ClassNaming.Builder classNamingBuilder) throws IOException {
     MemberNaming lastAddedNaming = null;
-    MemberNaming activeMemberNaming = null;
+    // To ensure we only commit a member if we have the residual signature, we delay creating the
+    // object and have the variables out here.
+    Signature previousOriginalSignature = null;
+    String previousRenamedName = null;
+    int previousLineNumber = -1;
+    Range previousRange = null;
+    Box<Signature> currentResidualSignature = new Box<>();
+    Box<List<ReferentialMappingInformation>> currentMappingInfoForMemberNaming = new Box<>();
     MappedRange activeMappedRange = null;
-    Range previousMappedRange = null;
     do {
       Range originalRange = null;
       // Try to parse any information added in comments above member namings
       if (isCommentLineWithJsonBrace()) {
-        final MemberNaming currentMember = activeMemberNaming;
+        final String currentRenamedNameFinal = previousRenamedName;
         final MappedRange currentRange = activeMappedRange;
         // Reading global info should cause member mapping to return since we are now reading
         // headers pertaining to what could be a concatinated file.
@@ -349,38 +359,44 @@
         parseMappingInformation(
             info -> {
               readGlobalInfo.set(info.isGlobalMappingInformation());
-              // TODO(b/242673239): Support additional information for fields.
-              if (currentMember == null) {
+              if (currentRenamedNameFinal == null) {
                 classNamingBuilder.addMappingInformation(
                     info,
                     conflictingInfo ->
                         diagnosticsHandler.warning(
                             MappingInformationDiagnostics.notAllowedCombination(
                                 info, conflictingInfo, lineNo)));
-              } else if (currentRange != null) {
+                return;
+              }
+              // Always add information to the current range, this will ensure that additional
+              // information is always placed the same place.
+              if (currentRange != null) {
                 currentRange.addMappingInformation(
                     info,
                     conflictingInfo ->
                         diagnosticsHandler.warning(
                             MappingInformationDiagnostics.notAllowedCombination(
                                 info, conflictingInfo, lineNo)));
-                if (info.isResidualMethodSignatureMappingInformation()) {
-                  ResidualMethodSignatureMappingInformation residualSignatureInfo =
-                      info.asResidualMethodSignatureMappingInformation();
-                  MethodSignature residualSignature =
-                      new MethodSignature(
-                          currentMember.getRenamedName(),
-                          DescriptorUtils.descriptorToJavaType(
-                              residualSignatureInfo.getReturnType()),
-                          ArrayUtils.mapToStringArray(
-                              residualSignatureInfo.getParameters(),
-                              DescriptorUtils::descriptorToJavaType));
-                  residualSignature =
-                      signatureCache
-                          .computeIfAbsent(residualSignature, Function.identity())
-                          .asMethodSignature();
-                  currentMember.setResidualSignatureInternal(residualSignature);
-                  currentRange.setResidualSignatureInternal(residualSignature);
+              }
+              if (info.isReferentialMappingInformation()) {
+                ReferentialMappingInformation referentialMappingInformation =
+                    info.asReferentialMappingInformation();
+                MappingInformation.addMappingInformation(
+                    currentMappingInfoForMemberNaming.computeIfAbsent(ArrayList::new),
+                    referentialMappingInformation,
+                    conflictingInfo ->
+                        diagnosticsHandler.warning(
+                            MappingInformationDiagnostics.notAllowedCombination(
+                                info, conflictingInfo, lineNo)));
+                if (info.isResidualSignatureMappingInformation()) {
+                  Signature residualSignature =
+                      getResidualSignatureFromMappingInformation(
+                          info.asResidualSignatureMappingInformation(), currentRenamedNameFinal);
+                  currentResidualSignature.set(residualSignature);
+                  if (currentRange != null) {
+                    currentRange.setResidualSignatureInternal(
+                        residualSignature.asMethodSignature());
+                  }
                 }
               }
             });
@@ -431,7 +447,7 @@
         if (activeMappedRange != null
             && activeMappedRange.signature == signature
             && activeMappedRange.renamedName.equals(renamedName)) {
-          residualSignature = activeMappedRange.getResidualSignatureInternal();
+          residualSignature = activeMappedRange.getResidualSignature();
         }
         activeMappedRange =
             classNamingBuilder.addMappedRange(
@@ -442,51 +458,114 @@
       }
 
       assert mappedRange == null || signature.isMethodSignature();
-
-      // If this line refers to a member that should be added to classNamingBuilder (as opposed to
-      // an inner inlined callee) and it's different from the the previous activeMemberNaming, then
-      // flush (add) the current activeMemberNaming.
-      if (activeMemberNaming != null) {
-        boolean changedName = !activeMemberNaming.getRenamedName().equals(renamedName);
-        boolean changedMappedRange = !Objects.equals(previousMappedRange, mappedRange);
+      if (previousOriginalSignature != null) {
+        boolean changedName = !previousRenamedName.equals(renamedName);
+        boolean changedMappedRange =
+            previousRange == null || !Objects.equals(previousRange, mappedRange);
         boolean originalRangeChange = originalRange == null || !originalRange.isCardinal;
-        if (changedName
-            || previousMappedRange == null
-            || changedMappedRange
-            || originalRangeChange) {
-          if (lastAddedNaming == null
-              || !lastAddedNaming
-                  .getOriginalSignature()
-                  .equals(activeMemberNaming.getOriginalSignature())) {
-            classNamingBuilder.addMemberEntry(
-                activeMemberNaming, getResidualSignatureForMemberNaming(activeMemberNaming));
-            lastAddedNaming = activeMemberNaming;
-          }
+        if (changedName || changedMappedRange || originalRangeChange) {
+          lastAddedNaming =
+              addMemberEntryOrCopyInformation(
+                  lastAddedNaming,
+                  previousOriginalSignature,
+                  previousRenamedName,
+                  previousLineNumber,
+                  currentResidualSignature,
+                  currentMappingInfoForMemberNaming,
+                  previousRange,
+                  classNamingBuilder);
         }
       }
-      activeMemberNaming = new MemberNaming(signature, renamedName, getPosition());
-      previousMappedRange = mappedRange;
+      previousOriginalSignature = signature;
+      previousRenamedName = renamedName;
+      previousLineNumber = lineNo;
+      previousRange = mappedRange;
     } while (nextLine(mapBuilder));
 
-    if (activeMemberNaming != null) {
-      boolean notAdded =
-          lastAddedNaming == null
-              || !lastAddedNaming
-                  .getOriginalSignature()
-                  .equals(activeMemberNaming.getOriginalSignature());
-      if (previousMappedRange == null || notAdded) {
-        classNamingBuilder.addMemberEntry(
-            activeMemberNaming, getResidualSignatureForMemberNaming(activeMemberNaming));
-      }
+    if (previousOriginalSignature != null) {
+      addMemberEntryOrCopyInformation(
+          lastAddedNaming,
+          previousOriginalSignature,
+          previousRenamedName,
+          previousLineNumber,
+          currentResidualSignature,
+          currentMappingInfoForMemberNaming,
+          previousRange,
+          classNamingBuilder);
     }
   }
 
-  private Signature getResidualSignatureForMemberNaming(MemberNaming memberNaming) {
-    if (memberNaming.hasResidualSignature()) {
-      return memberNaming.getResidualSignatureInternal();
+  private MemberNaming addMemberEntryOrCopyInformation(
+      MemberNaming lastAddedNaming,
+      Signature originalSignature,
+      String renamedName,
+      int lineNumber,
+      Box<Signature> residualSignature,
+      Box<List<ReferentialMappingInformation>> additionalMappingInformation,
+      Range previousMappedRange,
+      ClassNaming.Builder classNamingBuilder) {
+    // If this line refers to a member that should be added to classNamingBuilder (as opposed to
+    // an inner inlined callee) and it's different from the the previous activeMemberNaming, then
+    // flush (add) the current activeMemberNaming.
+    if (previousMappedRange == null
+        || lastAddedNaming == null
+        || !lastAddedNaming.getRenamedName().equals(renamedName)
+        || !lastAddedNaming.getOriginalSignature().equals(originalSignature)) {
+      MemberNaming newMemberNaming =
+          new MemberNaming(
+              originalSignature,
+              getResidualSignatureForMemberNaming(
+                  residualSignature, originalSignature, renamedName),
+              new LinePosition(lineNumber));
+      if (additionalMappingInformation.isSet()) {
+        newMemberNaming.addAllMappingInformationInternal(additionalMappingInformation.get());
+      }
+      classNamingBuilder.addMemberEntry(newMemberNaming);
+      residualSignature.clear();
+      additionalMappingInformation.clear();
+      return newMemberNaming;
     }
-    Signature signature =
-        memberNaming.getOriginalSignature().asRenamed(memberNaming.getRenamedName());
+    if (additionalMappingInformation.isSet()) {
+      lastAddedNaming.addAllMappingInformationInternal(additionalMappingInformation.get());
+      additionalMappingInformation.clear();
+    }
+    residualSignature.clear();
+    return lastAddedNaming;
+  }
+
+  private Signature getResidualSignatureFromMappingInformation(
+      ResidualSignatureMappingInformation mappingInformation, String renamedName) {
+    if (mappingInformation.isResidualMethodSignatureMappingInformation()) {
+      ResidualMethodSignatureMappingInformation residualSignatureInfo =
+          mappingInformation.asResidualMethodSignatureMappingInformation();
+      MethodSignature residualSignature =
+          new MethodSignature(
+              renamedName,
+              DescriptorUtils.descriptorToJavaType(residualSignatureInfo.getReturnType()),
+              ArrayUtils.mapToStringArray(
+                  residualSignatureInfo.getParameters(), DescriptorUtils::descriptorToJavaType));
+      return signatureCache
+          .computeIfAbsent(residualSignature, Function.identity())
+          .asMethodSignature();
+    } else {
+      assert mappingInformation.isResidualFieldSignatureMappingInformation();
+      ResidualFieldSignatureMappingInformation residualSignatureInfo =
+          mappingInformation.asResidualFieldSignatureMappingInformation();
+      FieldSignature residualSignature =
+          new FieldSignature(
+              renamedName, DescriptorUtils.descriptorToJavaType(residualSignatureInfo.getType()));
+      return signatureCache
+          .computeIfAbsent(residualSignature, Function.identity())
+          .asFieldSignature();
+    }
+  }
+
+  private Signature getResidualSignatureForMemberNaming(
+      Box<Signature> residualSignature, Signature originalSignature, String renamedName) {
+    if (residualSignature.isSet()) {
+      return residualSignature.get();
+    }
+    Signature signature = originalSignature.asRenamed(renamedName);
     signature = signatureCache.computeIfAbsent(signature, Function.identity());
     return signature;
   }
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
index b1d1eff..8ddef2b 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
@@ -6,11 +6,12 @@
 
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonPrimitive;
 import java.util.function.Consumer;
 
-public class CompilerSynthesizedMappingInformation extends MappingInformation {
+public class CompilerSynthesizedMappingInformation extends ReferentialMappingInformation {
 
   public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_1_0;
   public static final String ID = "com.android.tools.r8.synthesized";
@@ -55,7 +56,7 @@
 
   @Override
   public boolean allowOther(MappingInformation information) {
-    return !information.isCompilerSynthesizedMappingInformation();
+    return true;
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
index 828b5d8..7535bd3 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
@@ -7,12 +7,13 @@
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonPrimitive;
 import java.util.function.Consumer;
 
-public class FileNameInformation extends MappingInformation {
+public class FileNameInformation extends ReferentialMappingInformation {
 
   private final String fileName;
 
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
index c62d4e6..6680142 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualMethodSignatureMappingInformation;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import java.util.List;
 import java.util.function.Consumer;
 
 public abstract class MappingInformation {
@@ -89,6 +90,10 @@
     return null;
   }
 
+  public ResidualSignatureMappingInformation asResidualSignatureMappingInformation() {
+    return null;
+  }
+
   public ResidualMethodSignatureMappingInformation asResidualMethodSignatureMappingInformation() {
     return null;
   }
@@ -177,6 +182,39 @@
     }
   }
 
+  public boolean isPositionalMappingInformation() {
+    return false;
+  }
+
+  public boolean isReferentialMappingInformation() {
+    return false;
+  }
+
+  public ReferentialMappingInformation asReferentialMappingInformation() {
+    return null;
+  }
+
+  public abstract static class ReferentialMappingInformation extends MappingInformation {
+
+    @Override
+    public boolean isReferentialMappingInformation() {
+      return true;
+    }
+
+    @Override
+    public ReferentialMappingInformation asReferentialMappingInformation() {
+      return this;
+    }
+  }
+
+  public abstract static class PositionalMappingInformation extends MappingInformation {
+
+    @Override
+    public boolean isPositionalMappingInformation() {
+      return true;
+    }
+  }
+
   static JsonElement getJsonElementFromObject(
       JsonObject object,
       DiagnosticsHandler diagnosticsHandler,
@@ -190,4 +228,15 @@
     }
     return element;
   }
+
+  public static <T extends MappingInformation> void addMappingInformation(
+      List<T> existingInfos, T newInfo, Consumer<MappingInformation> onProhibitedAddition) {
+    for (MappingInformation existing : existingInfos) {
+      if (!existing.allowOther(newInfo)) {
+        onProhibitedAddition.accept(existing);
+        return;
+      }
+    }
+    existingInfos.add(newInfo);
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
index b38d707..238a9dd 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.google.gson.JsonElement;
@@ -16,7 +17,7 @@
 import it.unimi.dsi.fastutil.ints.Int2IntSortedMap;
 import java.util.function.Consumer;
 
-public class OutlineCallsiteMappingInformation extends MappingInformation {
+public class OutlineCallsiteMappingInformation extends PositionalMappingInformation {
 
   public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
   public static final MapVersion SUPPORTED_WITH_OUTLINE_VERSION = MapVersion.MAP_VERSION_2_1;
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
index 09c60d9..72b3b8f 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
@@ -6,11 +6,12 @@
 
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonPrimitive;
 import java.util.function.Consumer;
 
-public class OutlineMappingInformation extends MappingInformation {
+public class OutlineMappingInformation extends ReferentialMappingInformation {
 
   public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
   public static final String ID = "com.android.tools.r8.outline";
@@ -40,7 +41,7 @@
 
   @Override
   public boolean allowOther(MappingInformation information) {
-    return !information.isOutlineMappingInformation();
+    return true;
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
index 1c94da9..79c4023 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -20,7 +21,7 @@
 import java.util.Arrays;
 import java.util.function.Consumer;
 
-public abstract class ResidualSignatureMappingInformation extends MappingInformation {
+public abstract class ResidualSignatureMappingInformation extends ReferentialMappingInformation {
 
   public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_EXPERIMENTAL;
   public static final String ID = "com.android.tools.r8.residualsignature";
@@ -41,11 +42,6 @@
 
   protected abstract String serializeInternal();
 
-  @Override
-  public boolean allowOther(MappingInformation information) {
-    return !information.isResidualSignatureMappingInformation();
-  }
-
   public static boolean isSupported(MapVersion version) {
     return version.isGreaterThanOrEqualTo(SUPPORTED_VERSION);
   }
@@ -67,6 +63,16 @@
     }
   }
 
+  @Override
+  public boolean isResidualSignatureMappingInformation() {
+    return true;
+  }
+
+  @Override
+  public ResidualSignatureMappingInformation asResidualSignatureMappingInformation() {
+    return this;
+  }
+
   public static class ResidualMethodSignatureMappingInformation
       extends ResidualSignatureMappingInformation {
 
@@ -122,6 +128,16 @@
       assert existing.isResidualMethodSignatureMappingInformation();
       return this;
     }
+
+    @Override
+    public boolean allowOther(MappingInformation information) {
+      if (!information.isResidualMethodSignatureMappingInformation()) {
+        return true;
+      }
+      ResidualMethodSignatureMappingInformation other =
+          information.asResidualMethodSignatureMappingInformation();
+      return returnType.equals(other.returnType) && Arrays.equals(parameters, other.parameters);
+    }
   }
 
   public static class ResidualFieldSignatureMappingInformation
@@ -138,6 +154,10 @@
       return new ResidualFieldSignatureMappingInformation(field.getType().toDescriptorString());
     }
 
+    public String getType() {
+      return type;
+    }
+
     @Override
     protected String serializeInternal() {
       return type;
@@ -163,5 +183,11 @@
       assert existing.isResidualFieldSignatureMappingInformation();
       return this;
     }
+
+    @Override
+    public boolean allowOther(MappingInformation information) {
+      return !information.isResidualFieldSignatureMappingInformation()
+          || type.equals(information.asResidualFieldSignatureMappingInformation().getType());
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
index da0c1f3..589a743 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.retrace.internal.RetraceStackTraceContextImpl;
@@ -25,7 +26,7 @@
 import java.util.List;
 import java.util.function.Consumer;
 
-public class RewriteFrameMappingInformation extends MappingInformation {
+public class RewriteFrameMappingInformation extends PositionalMappingInformation {
 
   public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
   public static final String ID = "com.android.tools.r8.rewriteFrame";
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
index 3348063..98699b2 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
@@ -6,10 +6,11 @@
 
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
 import com.google.gson.JsonObject;
 import java.util.function.Consumer;
 
-public class UnknownJsonMappingInformation extends MappingInformation {
+public class UnknownJsonMappingInformation extends PositionalMappingInformation {
 
   private final String id;
   private final String payload;
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java b/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java
new file mode 100644
index 0000000..26d5a16
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.internal;
+
+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.utils.ListUtils;
+import java.util.List;
+
+class MemberNamingWithMappedRangesOfName {
+
+  private final MappedRangesOfName mappedRangesOfName;
+  private final MemberNaming methodMemberNaming;
+
+  MemberNamingWithMappedRangesOfName(
+      MemberNaming methodMemberNaming, MappedRangesOfName mappedRangesOfName) {
+    this.methodMemberNaming = methodMemberNaming;
+    this.mappedRangesOfName = mappedRangesOfName;
+  }
+
+  List<MappedRange> allRangesForLine(int line) {
+    return mappedRangesOfName.allRangesForLine(line, false);
+  }
+
+  List<MappedRange> mappedRangesWithNoMinifiedRange() {
+    return ListUtils.filter(
+        mappedRangesOfName.getMappedRanges(), mappedRange -> mappedRange.minifiedRange == null);
+  }
+
+  List<MappedRange> getMappedRanges() {
+    return mappedRangesOfName.getMappedRanges();
+  }
+
+  public MemberNaming getMemberNaming() {
+    return methodMemberNaming;
+  }
+}
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
index 1b2be6a..45ad91a 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
@@ -10,7 +10,6 @@
 import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.mappinginformation.MappingInformation;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
@@ -23,8 +22,8 @@
 import com.android.tools.r8.retrace.RetraceStackTraceContext;
 import com.android.tools.r8.retrace.RetraceUnknownJsonMappingInformationResult;
 import com.android.tools.r8.retrace.RetracedSourceFile;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Pair;
-import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.OptionalInt;
@@ -63,6 +62,32 @@
     return lookupField(FieldDefinition.create(fieldReference));
   }
 
+  private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
+    return lookup(
+        fieldDefinition,
+        RetraceClassResultImpl::lookupMemberNamingsForFieldDefinition,
+        RetraceFieldResultImpl::new);
+  }
+
+  private static List<MemberNaming> lookupMemberNamingsForFieldDefinition(
+      ClassNamingForNameMapper mapper, FieldDefinition fieldDefinition) {
+    List<MemberNaming> memberNamings =
+        mapper.mappedFieldNamingsByName.get(fieldDefinition.getName());
+    if (memberNamings == null || memberNamings.isEmpty()) {
+      return null;
+    }
+    if (fieldDefinition.isFullFieldDefinition()) {
+      FieldSignature fieldSignature =
+          FieldSignature.fromFieldReference(
+              fieldDefinition.asFullFieldDefinition().getFieldReference());
+      memberNamings =
+          ListUtils.filter(
+              memberNamings,
+              memberNaming -> memberNaming.getResidualSignature().equals(fieldSignature));
+    }
+    return memberNamings;
+  }
+
   @Override
   public RetraceMethodResultImpl lookupMethod(String methodName) {
     return lookupMethod(MethodDefinition.create(obfuscatedReference, methodName));
@@ -79,82 +104,64 @@
     return lookupMethod(MethodDefinition.create(reference));
   }
 
-  private static MethodSignature getSignature(
-      ClassNamingForNameMapper mapper, MethodDefinition definition) {
-    if (mapper != null && definition.isFullMethodDefinition()) {
-      MemberNaming lookup =
-          mapper.lookup(
-              MethodSignature.fromMethodReference(
-                  definition.asFullMethodDefinition().getMethodReference()));
-      if (lookup != null) {
-        return lookup.getOriginalSignature().asMethodSignature();
-      }
-    }
-    return null;
-  }
-
-  private static FieldSignature getSignature(
-      ClassNamingForNameMapper mapper, FieldDefinition definition) {
-    if (mapper != null && definition.isFullFieldDefinition()) {
-      MemberNaming lookup =
-          mapper.lookup(
-              FieldSignature.fromFieldReference(
-                  definition.asFullFieldDefinition().getFieldReference()));
-      if (lookup != null) {
-        return lookup.getOriginalSignature().asFieldSignature();
-      }
-    }
-    return null;
-  }
-
-  private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
-    return lookup(
-        fieldDefinition,
-        getSignature(mapper, 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,
-        getSignature(mapper, methodDefinition),
-        (mapper, name) -> {
-          MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
-          if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
-            return null;
-          }
-          return mappedRanges.getMappedRanges();
-        },
+        RetraceClassResultImpl::lookupMappedRangesForMethodDefinition,
         RetraceMethodResultImpl::new);
   }
 
-  private <T, R, D extends Definition, S extends Signature> R lookup(
+  private static List<MemberNamingWithMappedRangesOfName> lookupMappedRangesForMethodDefinition(
+      ClassNamingForNameMapper mapper, MethodDefinition methodDefinition) {
+    MappedRangesOfName mappedRanges =
+        mapper.mappedRangesByRenamedName.get(methodDefinition.getName());
+    if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
+      return null;
+    }
+    List<MappedRangesOfName> partitions = mappedRanges.partitionOnMethodSignature();
+    if (methodDefinition.isFullMethodDefinition()) {
+      MethodSignature methodSignature =
+          MethodSignature.fromMethodReference(
+              methodDefinition.asFullMethodDefinition().getMethodReference());
+      partitions =
+          ListUtils.filter(
+              partitions,
+              partition ->
+                  ListUtils.last(partition.getMappedRanges())
+                      .getResidualSignature()
+                      .equals(methodSignature));
+    }
+    boolean isAmbiguous = partitions.size() > 1;
+    return ListUtils.map(
+        partitions,
+        mappedRangesOfName ->
+            new MemberNamingWithMappedRangesOfName(
+                mappedRangesOfName.getMemberNaming(mapper, isAmbiguous), mappedRangesOfName));
+  }
+
+  private static <T, D extends Definition> void lookupElement(
+      RetraceClassElementImpl element,
       D definition,
-      S originalSignature,
-      BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
-      ResultConstructor<T, R, D, S> constructor) {
+      List<Pair<RetraceClassElementImpl, T>> mappings,
+      BiFunction<ClassNamingForNameMapper, D, T> lookupFunction) {
+    if (element.mapper != null) {
+      T mappedElements = lookupFunction.apply(element.mapper, definition);
+      if (mappedElements != null) {
+        mappings.add(new Pair<>(element, mappedElements));
+        return;
+      }
+    }
+    mappings.add(new Pair<>(element, null));
+  }
+
+  private <T, R, D extends Definition> R lookup(
+      D definition,
+      BiFunction<ClassNamingForNameMapper, D, T> lookupFunction,
+      ResultConstructor<T, R, D> constructor) {
     List<Pair<RetraceClassElementImpl, 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, originalSignature, retracer);
+        .forEach(element -> lookupElement(element, definition, mappings, lookupFunction));
+    return constructor.create(this, mappings, definition, retracer);
   }
 
   @Override
@@ -212,12 +219,11 @@
         mapper);
   }
 
-  private interface ResultConstructor<T, R, D, S> {
+  private interface ResultConstructor<T, R, D> {
     R create(
         RetraceClassResultImpl classResult,
         List<Pair<RetraceClassElementImpl, T>> mappings,
         D definition,
-        S originalSignature,
         RetracerImpl retracer);
   }
 
@@ -271,14 +277,7 @@
     private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
       return lookup(
           fieldDefinition,
-          getSignature(mapper, fieldDefinition),
-          (mapper, name) -> {
-            List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
-            if (memberNamings == null || memberNamings.isEmpty()) {
-              return null;
-            }
-            return memberNamings;
-          },
+          RetraceClassResultImpl::lookupMemberNamingsForFieldDefinition,
           RetraceFieldResultImpl::new);
     }
 
@@ -290,34 +289,17 @@
     private RetraceMethodResultImpl lookupMethod(MethodDefinition methodDefinition) {
       return lookup(
           methodDefinition,
-          getSignature(mapper, methodDefinition),
-          (mapper, name) -> {
-            MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
-            if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
-              return null;
-            }
-            return mappedRanges.getMappedRanges();
-          },
+          RetraceClassResultImpl::lookupMappedRangesForMethodDefinition,
           RetraceMethodResultImpl::new);
     }
 
-    private <T, R, D extends Definition, S extends Signature> R lookup(
+    private <T, R, D extends Definition> R lookup(
         D definition,
-        S originalSignature,
-        BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
-        ResultConstructor<T, R, D, S> constructor) {
-      List<Pair<RetraceClassElementImpl, 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, originalSignature, classResult.retracer);
+        BiFunction<ClassNamingForNameMapper, D, T> lookupFunction,
+        ResultConstructor<T, R, D> constructor) {
+      List<Pair<RetraceClassElementImpl, T>> mappings = new ArrayList<>();
+      RetraceClassResultImpl.lookupElement(this, definition, mappings, lookupFunction);
+      return constructor.create(classResult, mappings, definition, classResult.retracer);
     }
 
     @Override
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
index d1d7203..afade35 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.retrace.internal;
 
-import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.references.Reference;
@@ -23,19 +22,16 @@
   private final RetraceClassResultImpl classResult;
   private final List<Pair<RetraceClassElementImpl, List<MemberNaming>>> memberNamings;
   private final FieldDefinition fieldDefinition;
-  private final FieldSignature originalFieldSignature;
   private final Retracer retracer;
 
   RetraceFieldResultImpl(
       RetraceClassResultImpl classResult,
       List<Pair<RetraceClassElementImpl, List<MemberNaming>>> memberNamings,
       FieldDefinition fieldDefinition,
-      FieldSignature originalFieldSignature,
       Retracer retracer) {
     this.classResult = classResult;
     this.memberNamings = memberNamings;
     this.fieldDefinition = fieldDefinition;
-    this.originalFieldSignature = originalFieldSignature;
     this.retracer = retracer;
     assert classResult != null;
     assert !memberNamings.isEmpty();
@@ -55,7 +51,8 @@
                         classElement,
                         RetracedFieldReferenceImpl.create(
                             fieldDefinition.substituteHolder(
-                                classElement.getRetracedClass().getClassReference()))));
+                                classElement.getRetracedClass().getClassReference())),
+                        null));
               }
               return memberNamings.stream()
                   .map(
@@ -78,7 +75,8 @@
                                     fieldSignature.isQualified()
                                         ? fieldSignature.toUnqualifiedName()
                                         : fieldSignature.name,
-                                    Reference.typeFromTypeName(fieldSignature.type))));
+                                    Reference.typeFromTypeName(fieldSignature.type))),
+                            memberNaming);
                       });
             });
   }
@@ -105,23 +103,27 @@
     private final RetracedFieldReferenceImpl fieldReference;
     private final RetraceFieldResultImpl retraceFieldResult;
     private final RetraceClassElementImpl classElement;
+    private final MemberNaming memberNaming;
 
     private ElementImpl(
         RetraceFieldResultImpl retraceFieldResult,
         RetraceClassElementImpl classElement,
-        RetracedFieldReferenceImpl fieldReference) {
+        RetracedFieldReferenceImpl fieldReference,
+        MemberNaming memberNaming) {
       this.classElement = classElement;
       this.fieldReference = fieldReference;
       this.retraceFieldResult = retraceFieldResult;
+      this.memberNaming = memberNaming;
     }
 
     @Override
     public boolean isCompilerSynthesized() {
-      throw new Unimplemented("b/172014416");
+      return memberNaming != null && memberNaming.isCompilerSynthesized();
     }
 
     @Override
     public boolean isUnknown() {
+      assert (memberNaming == null) == fieldReference.isUnknown();
       return fieldReference.isUnknown();
     }
 
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
index 9d22b04..cfaa06e 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
@@ -8,6 +8,7 @@
 
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.Range;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.retrace.RetraceFrameElement;
@@ -36,7 +37,8 @@
   private final RetraceClassResultImpl classResult;
   private final MethodDefinition methodDefinition;
   private final OptionalInt obfuscatedPosition;
-  private final List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges;
+  private final List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>>
+      mappedRanges;
   private final RetracerImpl retracer;
   private final RetraceStackTraceContextImpl context;
 
@@ -44,7 +46,7 @@
 
   public RetraceFrameResultImpl(
       RetraceClassResultImpl classResult,
-      List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges,
+      List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> mappedRanges,
       MethodDefinition methodDefinition,
       OptionalInt obfuscatedPosition,
       RetracerImpl retracer,
@@ -55,35 +57,46 @@
     this.mappedRanges = mappedRanges;
     this.retracer = retracer;
     this.context = context;
+    assert !mappedRanges.isEmpty();
   }
 
   @Override
   public boolean isAmbiguous() {
     if (isAmbiguousCache.isUnknown()) {
-      if (mappedRanges.size() > 1) {
-        isAmbiguousCache = OptionalBool.TRUE;
-        return true;
-      }
-      List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
-      if (methodRanges != null && !methodRanges.isEmpty()) {
-        MappedRange initialRange = methodRanges.get(0);
-        for (MappedRange mappedRange : methodRanges) {
-          if (isMappedRangeAmbiguous(mappedRange)) {
-            isAmbiguousCache = OptionalBool.TRUE;
-            return true;
-          }
-          if (mappedRange != initialRange
-              && (mappedRange.minifiedRange == null
-                  || !mappedRange.minifiedRange.equals(initialRange.minifiedRange))) {
-            isAmbiguousCache = OptionalBool.TRUE;
-            return true;
-          }
+      isAmbiguousCache = OptionalBool.of(computeIsAmbiguous());
+      assert !isAmbiguousCache.isUnknown();
+    }
+    return isAmbiguousCache.isTrue();
+  }
+
+  private boolean computeIsAmbiguous() {
+    if (mappedRanges.size() > 1) {
+      return true;
+    }
+    List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges =
+        mappedRanges.get(0).getSecond();
+    if (memberNamingWithMappedRanges == null) {
+      return false;
+    }
+    if (memberNamingWithMappedRanges.size() > 1) {
+      return true;
+    }
+    assert !memberNamingWithMappedRanges.isEmpty();
+    List<MappedRange> methodRanges = memberNamingWithMappedRanges.get(0).getMappedRanges();
+    if (methodRanges != null && !methodRanges.isEmpty()) {
+      MappedRange initialRange = methodRanges.get(0);
+      for (MappedRange mappedRange : methodRanges) {
+        if (isMappedRangeAmbiguous(mappedRange)) {
+          return true;
+        }
+        if (mappedRange != initialRange
+            && (mappedRange.minifiedRange == null
+                || !mappedRange.minifiedRange.equals(initialRange.minifiedRange))) {
+          return true;
         }
       }
-      isAmbiguousCache = OptionalBool.FALSE;
     }
-    assert !isAmbiguousCache.isUnknown();
-    return isAmbiguousCache.isTrue();
+    return false;
   }
 
   private boolean isMappedRangeAmbiguous(MappedRange mappedRange) {
@@ -102,8 +115,10 @@
         .flatMap(
             mappedRangePair -> {
               RetraceClassElementImpl classElement = mappedRangePair.getFirst();
-              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
-              if (mappedRanges == null || mappedRanges.isEmpty()) {
+              List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRangesOfNames =
+                  mappedRangePair.getSecond();
+              if (memberNamingWithMappedRangesOfNames == null
+                  || memberNamingWithMappedRangesOfNames.isEmpty()) {
                 return Stream.of(
                     new ElementImpl(
                         this,
@@ -112,32 +127,46 @@
                             methodDefinition.substituteHolder(
                                 classElement.getRetracedClass().getClassReference())),
                         ImmutableList.of(),
+                        null,
                         obfuscatedPosition,
                         retracer));
               }
               // 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
-                  separateAmbiguousOriginalPositions(
-                      classElement, mappedRangesForElement, ambiguousFrames);
-                  mappedRangesForElement = new ArrayList<>();
-                  minifiedRange = mappedRange.minifiedRange;
+              for (MemberNamingWithMappedRangesOfName memberNamingWithMappedRangesOfName :
+                  memberNamingWithMappedRangesOfNames) {
+                List<MappedRange> mappedRangesForMemberNaming =
+                    memberNamingWithMappedRangesOfName.getMappedRanges();
+                MappedRange firstMappedRange = mappedRangesForMemberNaming.get(0);
+                Range minifiedRange = firstMappedRange.minifiedRange;
+                List<MappedRange> mappedRangesForElement = Lists.newArrayList(firstMappedRange);
+                for (int i = 1; i < mappedRangesForMemberNaming.size(); i++) {
+                  MappedRange mappedRange = mappedRangesForMemberNaming.get(i);
+                  if (minifiedRange == null || !minifiedRange.equals(mappedRange.minifiedRange)) {
+                    // This is a new frame
+                    separateAmbiguousOriginalPositions(
+                        classElement,
+                        memberNamingWithMappedRangesOfName.getMemberNaming(),
+                        mappedRangesForElement,
+                        ambiguousFrames);
+                    mappedRangesForElement = new ArrayList<>();
+                    minifiedRange = mappedRange.minifiedRange;
+                  }
+                  mappedRangesForElement.add(mappedRange);
                 }
-                mappedRangesForElement.add(mappedRange);
+                separateAmbiguousOriginalPositions(
+                    classElement,
+                    memberNamingWithMappedRangesOfName.getMemberNaming(),
+                    mappedRangesForElement,
+                    ambiguousFrames);
               }
-              separateAmbiguousOriginalPositions(
-                  classElement, mappedRangesForElement, ambiguousFrames);
               return ambiguousFrames.stream();
             });
   }
 
   private void separateAmbiguousOriginalPositions(
       RetraceClassElementImpl classElement,
+      MemberNaming memberNaming,
       List<MappedRange> frames,
       List<ElementImpl> allAmbiguousElements) {
     // We have a single list of frames where minified positional information may produce ambiguous
@@ -145,7 +174,7 @@
     if (!isAmbiguous() || !isMappedRangeAmbiguous(frames.get(0))) {
       allAmbiguousElements.add(
           elementFromMappedRanges(
-              ListUtils.map(frames, MappedRangeForFrame::create), classElement));
+              memberNaming, ListUtils.map(frames, MappedRangeForFrame::create), classElement));
       return;
     }
     assert frames.size() > 0;
@@ -165,19 +194,19 @@
             }
           } else {
             newFrames.forEach(
-                ambiguousFrames -> {
-                  ambiguousFrames.add(MappedRangeForFrame.create(frame));
-                });
+                ambiguousFrames -> ambiguousFrames.add(MappedRangeForFrame.create(frame)));
           }
         });
     newFrames.forEach(
-        ambiguousFrames -> {
-          allAmbiguousElements.add(elementFromMappedRanges(ambiguousFrames, classElement));
-        });
+        ambiguousFrames ->
+            allAmbiguousElements.add(
+                elementFromMappedRanges(memberNaming, ambiguousFrames, classElement)));
   }
 
   private ElementImpl elementFromMappedRanges(
-      List<MappedRangeForFrame> mappedRangesForElement, RetraceClassElementImpl classElement) {
+      MemberNaming memberNaming,
+      List<MappedRangeForFrame> mappedRangesForElement,
+      RetraceClassElementImpl classElement) {
     MappedRangeForFrame topFrame = mappedRangesForElement.get(0);
     MethodReference methodReference =
         methodReferenceFromMappedRange(
@@ -187,6 +216,7 @@
         classElement,
         getRetracedMethod(methodReference, topFrame, obfuscatedPosition),
         mappedRangesForElement,
+        memberNaming,
         obfuscatedPosition,
         retracer);
   }
@@ -221,7 +251,8 @@
 
   @Override
   public boolean isEmpty() {
-    return mappedRanges.isEmpty();
+    List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+    return mappedRangesOfNames == null || mappedRangesOfNames.isEmpty();
   }
 
   public static class ElementImpl implements RetraceFrameElement {
@@ -230,6 +261,7 @@
     private final RetraceFrameResultImpl retraceFrameResult;
     private final RetraceClassElementImpl classElement;
     private final List<MappedRangeForFrame> mappedRanges;
+    private final MemberNaming memberNaming;
     private final OptionalInt obfuscatedPosition;
     private final RetracerImpl retracer;
 
@@ -238,12 +270,14 @@
         RetraceClassElementImpl classElement,
         RetracedMethodReferenceImpl methodReference,
         List<MappedRangeForFrame> mappedRanges,
+        MemberNaming memberNaming,
         OptionalInt obfuscatedPosition,
         RetracerImpl retracer) {
       this.methodReference = methodReference;
       this.retraceFrameResult = retraceFrameResult;
       this.classElement = classElement;
       this.mappedRanges = mappedRanges;
+      this.memberNaming = memberNaming;
       this.obfuscatedPosition = obfuscatedPosition;
       this.retracer = retracer;
     }
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
index 19b2c15..1a6ca9a 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
@@ -4,9 +4,9 @@
 
 package com.android.tools.r8.retrace.internal;
 
-import com.android.tools.r8.errors.Unimplemented;
 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.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.mappinginformation.OutlineCallsiteMappingInformation;
 import com.android.tools.r8.references.MethodReference;
@@ -19,30 +19,26 @@
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Pair;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.OptionalInt;
-import java.util.Set;
 import java.util.stream.Stream;
 
 public class RetraceMethodResultImpl implements RetraceMethodResult {
 
   private final MethodDefinition methodDefinition;
-  private final MethodSignature originalMethodSignature;
   private final RetraceClassResultImpl classResult;
-  private final List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges;
+  private final List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>>
+      mappedRanges;
   private final RetracerImpl retracer;
 
   RetraceMethodResultImpl(
       RetraceClassResultImpl classResult,
-      List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges,
+      List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> mappedRanges,
       MethodDefinition methodDefinition,
-      MethodSignature originalMethodSignature,
       RetracerImpl retracer) {
     this.classResult = classResult;
     this.mappedRanges = mappedRanges;
     this.methodDefinition = methodDefinition;
-    this.originalMethodSignature = originalMethodSignature;
     this.retracer = retracer;
     assert classResult != null;
     assert !mappedRanges.isEmpty();
@@ -53,73 +49,71 @@
     if (mappedRanges.size() > 1) {
       return true;
     }
-    if (originalMethodSignature != null) {
-      return false;
-    }
-    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;
+    List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+    return mappedRangesOfNames != null && mappedRangesOfNames.size() > 1;
   }
 
   @Override
   public boolean isEmpty() {
-    return mappedRanges == null || mappedRanges.isEmpty();
+    List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+    return mappedRangesOfNames == null || mappedRangesOfNames.isEmpty();
   }
 
   @Override
   public RetraceFrameResultImpl narrowByPosition(
       RetraceStackTraceContext context, OptionalInt position) {
-    List<Pair<RetraceClassElementImpl, List<MappedRange>>> narrowedRanges = new ArrayList<>();
+    List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> narrowedRanges =
+        new ArrayList<>();
     RetraceStackTraceContextImpl stackTraceContext = null;
     if (context instanceof RetraceStackTraceContextImpl) {
       stackTraceContext = (RetraceStackTraceContextImpl) context;
     }
-    for (Pair<RetraceClassElementImpl, List<MappedRange>> mappedRange : mappedRanges) {
-      if (mappedRange.getSecond() == null) {
+    for (Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange :
+        mappedRanges) {
+      List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges =
+          mappedRange.getSecond();
+      if (memberNamingWithMappedRanges == null) {
         narrowedRanges.add(new Pair<>(mappedRange.getFirst(), null));
         continue;
       }
-      MappedRangesOfName mappedRangesOfElement = new MappedRangesOfName(mappedRange.getSecond());
-      List<MappedRange> mappedRangesForPosition = null;
       boolean hasPosition = position.isPresent() && position.getAsInt() >= 0;
-      if (hasPosition) {
-        mappedRangesForPosition =
-            mappedRangesOfElement.allRangesForLine(position.getAsInt(), false);
-      }
-      if (mappedRangesForPosition == null || mappedRangesForPosition.isEmpty()) {
-        mappedRangesForPosition =
-            hasPosition
-                ? ListUtils.filter(
-                    mappedRangesOfElement.getMappedRanges(), range -> range.minifiedRange == null)
-                : mappedRangesOfElement.getMappedRanges();
-      }
-      if (mappedRangesForPosition != null && !mappedRangesForPosition.isEmpty()) {
-        if (stackTraceContext != null && stackTraceContext.hasRewritePosition()) {
-          List<OutlineCallsiteMappingInformation> outlineCallsiteInformation =
-              ListUtils.last(mappedRangesForPosition).getOutlineCallsiteInformation();
-          if (!outlineCallsiteInformation.isEmpty()) {
-            assert outlineCallsiteInformation.size() == 1
-                : "There can only be one outline entry for a line";
-            return narrowByPosition(
-                stackTraceContext.buildFromThis().clearRewritePosition().build(),
-                OptionalInt.of(
-                    outlineCallsiteInformation
-                        .get(0)
-                        .rewritePosition(stackTraceContext.getRewritePosition())));
+      List<MemberNamingWithMappedRangesOfName> newMemberNamingsResult = new ArrayList<>();
+      for (MemberNamingWithMappedRangesOfName memberNamingWithMappedRange :
+          memberNamingWithMappedRanges) {
+        List<MappedRange> mappedRangesForPosition = null;
+        if (hasPosition) {
+          mappedRangesForPosition =
+              memberNamingWithMappedRange.allRangesForLine(position.getAsInt());
+        }
+        if (mappedRangesForPosition == null || mappedRangesForPosition.isEmpty()) {
+          mappedRangesForPosition =
+              hasPosition
+                  ? memberNamingWithMappedRange.mappedRangesWithNoMinifiedRange()
+                  : memberNamingWithMappedRange.getMappedRanges();
+        }
+        if (mappedRangesForPosition != null && !mappedRangesForPosition.isEmpty()) {
+          MemberNamingWithMappedRangesOfName newMemberNaming =
+              new MemberNamingWithMappedRangesOfName(
+                  memberNamingWithMappedRange.getMemberNaming(),
+                  new MappedRangesOfName(mappedRangesForPosition));
+          newMemberNamingsResult.add(newMemberNaming);
+          if (stackTraceContext != null && stackTraceContext.hasRewritePosition()) {
+            List<OutlineCallsiteMappingInformation> outlineCallsiteInformation =
+                ListUtils.last(mappedRangesForPosition).getOutlineCallsiteInformation();
+            if (!outlineCallsiteInformation.isEmpty()) {
+              assert outlineCallsiteInformation.size() == 1
+                  : "There can only be one outline entry for a line";
+              return narrowByPosition(
+                  stackTraceContext.buildFromThis().clearRewritePosition().build(),
+                  OptionalInt.of(
+                      outlineCallsiteInformation
+                          .get(0)
+                          .rewritePosition(stackTraceContext.getRewritePosition())));
+            }
           }
         }
-        narrowedRanges.add(new Pair<>(mappedRange.getFirst(), mappedRangesForPosition));
       }
+      narrowedRanges.add(new Pair<>(mappedRange.getFirst(), newMemberNamingsResult));
     }
     return new RetraceFrameResultImpl(
         classResult,
@@ -132,48 +126,43 @@
 
   @Override
   public Stream<RetraceMethodElement> stream() {
-    if (originalMethodSignature != null) {
-      // Even if we know exactly the retraced residual definition, the class element
-      // may still be ambiguous.
-      return mappedRanges.stream()
-          .map(
-              mappedRangePair -> {
-                RetraceClassElementImpl classElement = mappedRangePair.getFirst();
-                MethodReference methodReference =
-                    RetraceUtils.methodReferenceFromMethodSignature(
-                        originalMethodSignature,
-                        classElement.getRetracedClass().getClassReference());
-                return new ElementImpl(
-                    this, classElement, RetracedMethodReferenceImpl.create(methodReference));
-              });
-    }
     return mappedRanges.stream()
         .flatMap(
             mappedRangePair -> {
               RetraceClassElementImpl classElement = mappedRangePair.getFirst();
-              List<MappedRange> mappedRanges = mappedRangePair.getSecond();
-              if (mappedRanges == null || mappedRanges.isEmpty()) {
+              List<MemberNamingWithMappedRangesOfName> memberNamingsWithMappedRange =
+                  mappedRangePair.getSecond();
+              if (memberNamingsWithMappedRange == null || memberNamingsWithMappedRange.isEmpty()) {
                 return Stream.of(
                     new ElementImpl(
                         this,
                         classElement,
                         RetracedMethodReferenceImpl.create(
                             methodDefinition.substituteHolder(
-                                classElement.getRetracedClass().getClassReference()))));
+                                classElement.getRetracedClass().getClassReference())),
+                        null));
               }
-              List<ElementImpl> results = new ArrayList<>();
-              Set<MethodReference> seenMethodReferences = new HashSet<>();
-              for (MappedRange mappedRange : mappedRanges) {
-                MethodReference methodReference =
-                    RetraceUtils.methodReferenceFromMappedRange(
-                        mappedRange, classElement.getRetracedClass().getClassReference());
-                if (seenMethodReferences.add(methodReference)) {
-                  results.add(
-                      new ElementImpl(
-                          this, classElement, RetracedMethodReferenceImpl.create(methodReference)));
-                }
-              }
-              return results.stream();
+              return ListUtils.map(
+                  memberNamingsWithMappedRange,
+                  memberNamingWithMappedRangesOfName -> {
+                    MemberNaming memberNaming =
+                        memberNamingWithMappedRangesOfName.getMemberNaming();
+                    MethodSignature originalSignature =
+                        memberNaming != null
+                            ? memberNaming.getOriginalSignature().asMethodSignature()
+                            : ListUtils.last(memberNamingWithMappedRangesOfName.getMappedRanges())
+                                .getOriginalSignature()
+                                .asMethodSignature();
+                    MethodReference methodReference =
+                        RetraceUtils.methodReferenceFromMethodSignature(
+                            originalSignature, classElement.getRetracedClass().getClassReference());
+                    return new ElementImpl(
+                        this,
+                        classElement,
+                        RetracedMethodReferenceImpl.create(methodReference),
+                        memberNamingWithMappedRangesOfName);
+                  })
+                  .stream();
             });
   }
 
@@ -182,19 +171,28 @@
     private final RetracedMethodReferenceImpl methodReference;
     private final RetraceMethodResultImpl retraceMethodResult;
     private final RetraceClassElementImpl classElement;
+    private final MemberNamingWithMappedRangesOfName mapping;
 
     private ElementImpl(
         RetraceMethodResultImpl retraceMethodResult,
         RetraceClassElementImpl classElement,
-        RetracedMethodReferenceImpl methodReference) {
+        RetracedMethodReferenceImpl methodReference,
+        MemberNamingWithMappedRangesOfName mapping) {
       this.classElement = classElement;
       this.retraceMethodResult = retraceMethodResult;
       this.methodReference = methodReference;
+      this.mapping = mapping;
+      assert mapping != null;
     }
 
     @Override
     public boolean isCompilerSynthesized() {
-      throw new Unimplemented("b/172014416");
+      if (mapping.getMemberNaming() != null) {
+        return mapping.getMemberNaming().isCompilerSynthesized();
+      } else {
+        List<MappedRange> mappedRanges = mapping.getMappedRanges();
+        return !mappedRanges.isEmpty() && ListUtils.last(mappedRanges).isCompilerSynthesized();
+      }
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index fe4baac..7d23fa4 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -139,7 +139,7 @@
         if (appView.options().ignoreMissingClasses) {
           appView.reporter().warning(diagnostic);
         } else {
-          throw appView.reporter().fatalError(diagnostic);
+          appView.reporter().error(diagnostic);
         }
       }
       return build();
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java b/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
index cd7460b..69c9714 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
@@ -95,6 +95,8 @@
         return AndroidApiLevel.O;
       case V39:
         return AndroidApiLevel.P;
+      case V40:
+        return AndroidApiLevel.ANDROID_PLATFORM;
       default:
         throw new Unreachable();
     }
diff --git a/src/main/java/com/android/tools/r8/utils/DexVersion.java b/src/main/java/com/android/tools/r8/utils/DexVersion.java
index 492c87b..cdac93d 100644
--- a/src/main/java/com/android/tools/r8/utils/DexVersion.java
+++ b/src/main/java/com/android/tools/r8/utils/DexVersion.java
@@ -10,10 +10,11 @@
  * Android dex version
  */
 public enum DexVersion {
-  V35(35, new byte[]{'0', '3', '5'}),
-  V37(37, new byte[]{'0', '3', '7'}),
-  V38(38, new byte[]{'0', '3', '8'}),
-  V39(39, new byte[]{'0', '3', '9'});
+  V35(35, new byte[] {'0', '3', '5'}),
+  V37(37, new byte[] {'0', '3', '7'}),
+  V38(38, new byte[] {'0', '3', '8'}),
+  V39(39, new byte[] {'0', '3', '9'}),
+  V40(40, new byte[] {'0', '4', '0'});
 
   private final int dexVersion;
 
@@ -94,15 +95,23 @@
         return Optional.of(V38);
       case 39:
         return Optional.of(V39);
+      case 40:
+        return Optional.of(V40);
       default:
         return Optional.empty();
     }
   }
 
   public static Optional<DexVersion> getDexVersion(char b0, char b1, char b2) {
-    if (b0 != '0' || b1 != '3' || b2 < '5' || '9' < b2) {
+    if (b0 != '0') {
       return Optional.empty();
     }
-    return getDexVersion(100 * (b0 - '0') + 10 * (b1 - '0') + (b2 - '0'));
+    for (DexVersion candidate : DexVersion.values()) {
+      assert candidate.getBytes()[0] == '0';
+      if (candidate.getBytes()[2] == b2 && candidate.getBytes()[1] == b1) {
+        return Optional.of(candidate);
+      }
+    }
+    return Optional.empty();
   }
 }
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 6bf0a8f..ebd5a13 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -153,6 +153,7 @@
 
   public static final int SUPPORTED_DEX_VERSION =
       AndroidApiLevel.LATEST.getDexVersion().getIntValue();
+  public static final int EXPERIMENTAL_DEX_VERSION = DexVersion.V40.getIntValue();
 
   public static final int ASM_VERSION = Opcodes.ASM9;
 
@@ -1879,6 +1880,8 @@
     private boolean hasReadCheckDeterminism = false;
     private DeterminismChecker determinismChecker = null;
     public boolean usePcEncodingInCfForTesting = false;
+    public boolean dexContainerExperiment =
+        System.getProperty("com.android.tools.r8.dexContainerExperiment") != null;
 
     // Testing options to analyse locality of items in DEX files when they are generated.
     public boolean calculateItemUseCountInDex = false;
diff --git a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
index b87a2b5..646e09e 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
@@ -179,7 +179,7 @@
                   FieldSignature.fromDexField(originalField, originalField.holder != originalType);
               FieldSignature residualSignature = FieldSignature.fromDexField(residualField);
               MemberNaming memberNaming = new MemberNaming(originalSignature, residualSignature);
-              getBuilder().addMemberEntry(memberNaming, residualSignature);
+              getBuilder().addMemberEntry(memberNaming);
             }
           });
       return this;
@@ -227,7 +227,7 @@
       MethodSignature residualSignature = MethodSignature.fromDexMethod(residualMethod);
 
       MemberNaming memberNaming = new MemberNaming(originalSignature, residualSignature);
-      getBuilder().addMemberEntry(memberNaming, residualSignature);
+      getBuilder().addMemberEntry(memberNaming);
 
       // Add simple "a() -> b" mapping if we won't have any other with concrete line numbers
       if (mappedPositions.isEmpty()) {
diff --git a/src/test/examplesJava9/timeunit/Example.java b/src/test/examplesJava11/timeunit/Example.java
similarity index 85%
rename from src/test/examplesJava9/timeunit/Example.java
rename to src/test/examplesJava11/timeunit/Example.java
index 09e1d0c..003f8a4 100644
--- a/src/test/examplesJava9/timeunit/Example.java
+++ b/src/test/examplesJava11/timeunit/Example.java
@@ -4,6 +4,7 @@
 
 package timeunit;
 
+import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 import java.util.concurrent.TimeUnit;
 
@@ -12,5 +13,6 @@
   public static void main(String[] args) {
     TimeUnit timeUnit = TimeUnit.of(ChronoUnit.NANOS);
     System.out.println(timeUnit.toChronoUnit());
+    System.out.println(timeUnit.convert(Duration.ZERO));
   }
 }
diff --git a/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java b/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java
new file mode 100644
index 0000000..3c9713d
--- /dev/null
+++ b/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package stringconcatfactory;
+
+public class StringConcatFactoryUsage {
+
+  public static void main(String[] args) {
+    System.out.println("Hello " + args.length);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
index 8ba7823..92604de 100644
--- a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
+++ b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.UnverifiableCfCodeDiagnostic;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -95,7 +96,9 @@
             diagnostics -> {
               diagnostics.assertErrorsMatch(
                   diagnosticMessage(containsString("java.util.concurrent.Flow$Subscriber")));
-              diagnostics.assertOnlyErrors();
+              // TODO(b/251482856): Unexpected unverifiable code.
+              diagnostics.assertWarningsMatch(diagnosticType(UnverifiableCfCodeDiagnostic.class));
+              diagnostics.assertNoInfos();
               if (parameters.isDexRuntime()) {
                 // TODO(b/175659048): This should likely be a desugar diagnostic.
                 diagnostics.assertErrorsMatch(diagnosticType(MissingDefinitionsDiagnostic.class));
diff --git a/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java b/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
index f7be6ca..b6f5848 100644
--- a/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
+++ b/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
@@ -22,7 +22,7 @@
 public class FailCompilationOnFutureVersionsTest extends TestBase {
 
   static final int UNSUPPORTED_CF_VERSION = InternalOptions.SUPPORTED_CF_VERSION.major() + 1;
-  static final int UNSUPPORTED_DEX_VERSION = InternalOptions.SUPPORTED_DEX_VERSION + 1;
+  static final int UNSUPPORTED_DEX_VERSION = InternalOptions.EXPERIMENTAL_DEX_VERSION + 1;
 
   private final TestParameters parameters;
 
@@ -68,6 +68,40 @@
   }
 
   @Test
+  public void testExperimentatDexVersion() throws CompilationFailedException, IOException {
+    // Generate a DEX file with a version higher than the supported one.
+    Path out =
+        testForD8()
+            .addProgramClasses(TestClass.class)
+            .setMinApi(parameters.getApiLevel())
+            .addOptionsModification(
+                options ->
+                    options.testing.forceDexVersionBytes =
+                        ("0" + InternalOptions.EXPERIMENTAL_DEX_VERSION).getBytes())
+            .compile()
+            .writeToZip();
+    try {
+      testForD8()
+          .addProgramFiles(out)
+          .setMinApi(parameters.getApiLevel())
+          .compileWithExpectedDiagnostics(
+              diagnotics -> {
+                diagnotics.assertOnlyErrors();
+                diagnotics.assertErrorsCount(1);
+                assertThat(
+                    diagnotics.getErrors().get(0).getDiagnosticMessage(),
+                    containsString(
+                        "Dex file with version '"
+                            + InternalOptions.EXPERIMENTAL_DEX_VERSION
+                            + "' cannot be used with min sdk level "));
+              });
+    } catch (CompilationFailedException e) {
+      return;
+    }
+    fail("Expected compilation error");
+  }
+
+  @Test
   public void testCf() {
     try {
       testForD8()
diff --git a/src/test/java/com/android/tools/r8/L8TestCompileResult.java b/src/test/java/com/android/tools/r8/L8TestCompileResult.java
index fd5af1c..30744c3 100644
--- a/src/test/java/com/android/tools/r8/L8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/L8TestCompileResult.java
@@ -77,7 +77,7 @@
   }
 
   public <E extends Throwable> L8TestCompileResult inspectKeepRules(
-      ThrowingConsumer<List<String>, E> consumer) throws Throwable {
+      ThrowingConsumer<List<String>, E> consumer) throws E {
     consumer.accept(allKeepRules);
     return self();
   }
diff --git a/src/test/java/com/android/tools/r8/R8CfVersionTest.java b/src/test/java/com/android/tools/r8/R8CfVersionTest.java
index fcc29c1..d7ab6c8 100644
--- a/src/test/java/com/android/tools/r8/R8CfVersionTest.java
+++ b/src/test/java/com/android/tools/r8/R8CfVersionTest.java
@@ -18,7 +18,7 @@
 @RunWith(Parameterized.class)
 public class R8CfVersionTest extends TestBase {
 
-  private final CfVersion targetVersion = CfVersion.V1_8;
+  private final CfVersion targetVersion = CfVersion.V11;
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 2d25b7c..688ab43 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -178,7 +178,7 @@
         "Did you forget a keep rule for the run method?", mainFeatureClassSubject, isPresent());
     assertThat(
         "Did you forget a keep rule for the run method?",
-        mainFeatureClassSubject.uniqueMethodWithName("run"),
+        mainFeatureClassSubject.uniqueMethodWithOriginalName("run"),
         isPresent());
     String[] args = new String[2 + featureDependencies.length];
     args[0] = mainFeatureClassSubject.getFinalName();
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index a575af1..93f6288 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -46,7 +46,6 @@
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
-import com.android.tools.r8.profile.art.ArtProfileCollection;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
@@ -174,6 +173,11 @@
     return ExternalR8TestBuilder.create(new TestState(temp), backend, runtime);
   }
 
+  public static ExternalR8TestBuilder testForExternalR8(TemporaryFolder temp, Backend backend) {
+    return ExternalR8TestBuilder.create(
+        new TestState(temp), backend, TestRuntime.getSystemRuntime());
+  }
+
   public static D8TestBuilder testForD8(TemporaryFolder temp, Backend backend) {
     return D8TestBuilder.create(new TestState(temp), backend);
   }
@@ -214,6 +218,10 @@
     return testForExternalR8(temp, backend, runtime);
   }
 
+  public ExternalR8TestBuilder testForExternalR8(Backend backend) {
+    return testForExternalR8(temp, backend, TestRuntime.getSystemRuntime());
+  }
+
   public D8TestBuilder testForD8() {
     return testForD8(temp, Backend.DEX);
   }
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index 165cd83..cd6df4f 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -10,7 +10,6 @@
 
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.benchmarks.BenchmarkResults;
-import com.android.tools.r8.debug.DebugTestConfig;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorEventConsumer;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.MethodStateCollectionByReference;
 import com.android.tools.r8.testing.AndroidBuildVersion;
@@ -32,6 +31,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -226,6 +226,18 @@
     return internalCompileAndBenchmark(null);
   }
 
+  private Collection<Path> getDefaultLibraryFiles() {
+    if (backend == Backend.DEX) {
+      assert builder.isMinApiLevelSet();
+      return Collections.singletonList(
+          ToolHelper.getFirstSupportedAndroidJar(
+              AndroidApiLevel.getAndroidApiLevel(builder.getMinApiLevel())));
+    } else {
+      assert backend == Backend.CF;
+      return Collections.singletonList(ToolHelper.getJava8RuntimeJar());
+    }
+  }
+
   private CR internalCompileAndBenchmark(BenchmarkResults benchmark)
       throws CompilationFailedException {
     AndroidAppConsumers sink = new AndroidAppConsumers();
@@ -249,14 +261,7 @@
     }
     builder.setOptimizeMultidexForLinearAlloc(optimizeMultidexForLinearAlloc);
     if (useDefaultRuntimeLibrary) {
-      if (backend == Backend.DEX) {
-        assert builder.isMinApiLevelSet();
-        builder.addLibraryFiles(
-            ToolHelper.getFirstSupportedAndroidJar(
-                AndroidApiLevel.getAndroidApiLevel(builder.getMinApiLevel())));
-      } else {
-        builder.addLibraryFiles(TestBase.runtimeJar(backend));
-      }
+      builder.addLibraryFiles(getDefaultLibraryFiles());
     }
     assertNull(oldStdout);
     oldStdout = System.out;
diff --git a/src/test/java/com/android/tools/r8/TestRuntime.java b/src/test/java/com/android/tools/r8/TestRuntime.java
index 3524d63..0d937dd 100644
--- a/src/test/java/com/android/tools/r8/TestRuntime.java
+++ b/src/test/java/com/android/tools/r8/TestRuntime.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.structural.Ordered;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.ImmutableMap;
@@ -28,7 +29,7 @@
 public abstract class TestRuntime {
 
   // Enum describing the possible/supported CF runtimes.
-  public enum CfVm {
+  public enum CfVm implements Ordered<CfVm> {
     JDK8("jdk8", 52),
     JDK9("jdk9", 53),
     JDK10("jdk10", 54),
@@ -66,17 +67,21 @@
     }
 
     public boolean lessThan(CfVm other) {
-      return this.ordinal() < other.ordinal();
+      return isLessThan(other);
     }
 
     public boolean lessThanOrEqual(CfVm other) {
-      return this.ordinal() <= other.ordinal();
+      return isLessThanOrEqualTo(other);
     }
 
     @Override
     public String toString() {
       return name;
     }
+
+    public static CfVm getMinimumSystemVersion() {
+      return JDK11;
+    }
   }
 
   private static final Path JDK8_PATH = Paths.get(ToolHelper.THIRD_PARTY_DIR, "openjdk", "jdk8");
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
index 601208f..6b01a75 100644
--- a/src/test/java/com/android/tools/r8/TestState.java
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -12,7 +12,7 @@
 public class TestState {
 
   private final TemporaryFolder temp;
-  private final TestDiagnosticMessagesImpl messages = new TestDiagnosticMessagesImpl();
+  private final TestDiagnosticMessagesImpl messages;
 
   private Set<String> mainDexClasses;
 
@@ -20,7 +20,12 @@
   private String stderr;
 
   public TestState(TemporaryFolder temp) {
+    this(temp, new TestDiagnosticMessagesImpl());
+  }
+
+  public TestState(TemporaryFolder temp, TestDiagnosticMessagesImpl handler) {
     this.temp = temp;
+    this.messages = handler;
   }
 
   public TemporaryFolder getTempFolder() {
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
index 1307d62..0381e87 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
@@ -70,7 +70,7 @@
     ClassSubject classSubject = inspector.clazz(clazzWithGetter);
     assertThat(classSubject, isPresent());
 
-    FieldSubject fieldSubject = classSubject.uniqueFieldWithName("field");
+    FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("field");
     assertThat(fieldSubject, isPresent());
 
     // Although this field was explicitly kept, it is no longer private.
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
index b1c5fc8..ce4dc72 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
@@ -49,10 +49,10 @@
               ClassSubject mainClassSubject = inspector.clazz(Main.class);
               assertThat(mainClassSubject, isPresent());
               assertThat(
-                  mainClassSubject.uniqueFieldWithName("instanceField"),
+                  mainClassSubject.uniqueFieldWithOriginalName("instanceField"),
                   allOf(isPresent(), onlyIf(allowAccessModification, isFinal())));
               assertThat(
-                  mainClassSubject.uniqueFieldWithName("staticField"),
+                  mainClassSubject.uniqueFieldWithOriginalName("staticField"),
                   allOf(isPresent(), onlyIf(allowAccessModification, isFinal())));
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
index 45ddf3e..3358771 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
@@ -70,7 +70,8 @@
               ClassSubject subViewModelSubject =
                   inspector.clazz(DescriptorUtils.descriptorToJavaType(NEW_DESCRIPTOR));
               assertThat(subViewModelSubject, isPresent());
-              MethodSubject clearSubject = subViewModelSubject.uniqueMethodWithName("clear");
+              MethodSubject clearSubject =
+                  subViewModelSubject.uniqueMethodWithOriginalName("clear");
               assertThat(clearSubject, isPresent());
               assertTrue(clearSubject.isPublic());
             });
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
index 61c1d77..3aeeb72 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
@@ -71,11 +71,11 @@
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
     if (withKeepAllowAccessModification) {
-      assertThat(classSubject.uniqueFieldWithName("greeting"), isPublic());
-      assertThat(classSubject.uniqueMethodWithName("greet"), isPublic());
+      assertThat(classSubject.uniqueFieldWithOriginalName("greeting"), isPublic());
+      assertThat(classSubject.uniqueMethodWithOriginalName("greet"), isPublic());
     } else {
-      assertThat(classSubject.uniqueFieldWithName("greeting"), isPrivate());
-      assertThat(classSubject.uniqueMethodWithName("greet"), isPrivate());
+      assertThat(classSubject.uniqueFieldWithOriginalName("greeting"), isPrivate());
+      assertThat(classSubject.uniqueMethodWithOriginalName("greet"), isPrivate());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java b/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
index 59e8923..af2e5df 100644
--- a/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
@@ -81,7 +81,7 @@
             : ImmutableSet.of();
     assertEquals(
         expected,
-        inspector.clazz(TestClass.class).uniqueMethodWithName("main").annotations().stream()
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main").annotations().stream()
             .map(s -> s.getAnnotation().type.getDescriptor().toSourceString())
             .collect(Collectors.toSet()));
   }
diff --git a/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java b/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
index 8e8f4ee..97f6cd0 100644
--- a/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
+++ b/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
@@ -86,7 +86,7 @@
               getMaxAndroidApiLevelFromNode(memberNode, apiLevel));
         } else if (isField(memberNode)) {
           // The field do not have descriptors and are supposed to be unique.
-          FieldSubject fieldSubject = clazz.uniqueFieldWithName(getName(memberNode));
+          FieldSubject fieldSubject = clazz.uniqueFieldWithOriginalName(getName(memberNode));
           if (!fieldSubject.isPresent()) {
             assert hasRemoved(memberNode);
             assert getRemoved(memberNode).isLessThanOrEqualTo(maxApiLevel);
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
index f351779..284fbd5 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
@@ -63,7 +63,7 @@
               if (parameters.isDexRuntime()
                   && parameters.getApiLevel().isGreaterThanOrEqualTo(L_MR1)) {
                 ClassSubject mainSubject = inspector.clazz(Main.class);
-                MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithName("main");
+                MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithOriginalName("main");
                 assertThat(mainMethodSubject, isPresent());
                 assertThat(mainMethodSubject, CodeMatchers.invokesMethodWithName("apiLevel22"));
               }
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
index c8c4fe2..409cd9b 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
@@ -135,8 +135,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject libraryClassSubject = inspector.clazz(LibraryClass.class);
     assertThat(libraryClassSubject, isPresent());
-    assertThat(libraryClassSubject.uniqueMethodWithName("foo"), isPresent());
-    assertThat(libraryClassSubject.uniqueMethodWithName("bar"), isPresent());
+    assertThat(libraryClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+    assertThat(libraryClassSubject.uniqueMethodWithOriginalName("bar"), isPresent());
   }
 
   private void checkOutput(SingleTestRunResult<?> runResult) {
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
index dea3e93..b2611de 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
@@ -136,8 +136,8 @@
       assertThat(libraryClassSubject, isAbsent());
     } else {
       assertThat(libraryClassSubject, isPresent());
-      assertThat(libraryClassSubject.uniqueMethodWithName("foo"), isAbsent());
-      assertThat(libraryClassSubject.uniqueMethodWithName("bar"), isAbsent());
+      assertThat(libraryClassSubject.uniqueMethodWithOriginalName("foo"), isAbsent());
+      assertThat(libraryClassSubject.uniqueMethodWithOriginalName("bar"), isAbsent());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
index 9a243d3..c69756a 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
@@ -67,7 +67,8 @@
                   assert parameters.canUseDefaultAndStaticInterfaceMethods();
                   assertThat(apiCaller, isPresent());
                   assertThat(aSubject, isPresent());
-                  MethodSubject callApiLevel = apiCaller.uniqueMethodWithName("callApiLevel");
+                  MethodSubject callApiLevel =
+                      apiCaller.uniqueMethodWithOriginalName("callApiLevel");
                   assertThat(callApiLevel, CodeMatchers.invokesMethodWithName("apiLevel22"));
                 } else {
                   assert parameters.isDexRuntime();
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
index ed7b9eb..e5967cd 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
@@ -77,13 +77,13 @@
               } else {
                 assertThat(action, isPresent());
                 MethodSubject action$lambda$getAction$0 =
-                    action.uniqueMethodWithName("lambda$getAction$0");
+                    action.uniqueMethodWithOriginalName("lambda$getAction$0");
                 assertThat(action$lambda$getAction$0, isPresent());
                 assertThat(
                     action$lambda$getAction$0, CodeMatchers.invokesMethodWithName("apiLevel22"));
 
                 assertThat(apiCaller, isPresent());
-                MethodSubject callApi = apiCaller.uniqueMethodWithName("callApi");
+                MethodSubject callApi = apiCaller.uniqueMethodWithOriginalName("callApi");
                 assertThat(callApi, isPresent());
                 assertThat(callApi, CodeMatchers.invokesMethodWithName("apiLevel22"));
               }
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
index d974c7a..e2f517c 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
@@ -51,7 +51,8 @@
         .compile()
         .inspect(
             inspector -> {
-              FieldSubject fieldSubject = inspector.clazz(Main.class).uniqueFieldWithName("FIELD");
+              FieldSubject fieldSubject =
+                  inspector.clazz(Main.class).uniqueFieldWithOriginalName("FIELD");
               assertThat(fieldSubject, isPresent());
               assertEquals(
                   ApiLevel22.class.getTypeName(), fieldSubject.getField().getType().getTypeName());
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
index 1d17e5c..aea9a60 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
@@ -56,7 +56,8 @@
             inspector -> {
               Class<?> expectedFieldType =
                   isTypeStrengtheningSafe ? ApiLevel23.class : ApiLevel22.class;
-              FieldSubject fieldSubject = inspector.clazz(Main.class).uniqueFieldWithName("FIELD");
+              FieldSubject fieldSubject =
+                  inspector.clazz(Main.class).uniqueFieldWithOriginalName("FIELD");
               assertThat(fieldSubject, isPresent());
               assertEquals(
                   expectedFieldType.getTypeName(), fieldSubject.getField().getType().getTypeName());
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
index 04cacdf..d151f76 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
@@ -57,7 +57,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(B.class);
               assertThat(clazz, isPresent());
-              MethodSubject foo = clazz.uniqueMethodWithName("foo");
+              MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
               assertThat(foo, isPresent());
             });
   }
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 2472119..b63a54d 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -71,7 +71,7 @@
               ClassSubject classSubject = inspector.clazz(SimpleDataAdapter.class);
               assertThat(classSubject, isPresent());
 
-              MethodSubject subject = classSubject.uniqueMethodWithName("registerObserver");
+              MethodSubject subject = classSubject.uniqueMethodWithOriginalName("registerObserver");
               assertThat(subject, isPresent());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
index eac0142..f0e4af3 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
@@ -91,20 +91,20 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(BridgeHoistingAccessibilityTestClasses.A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("bridgeC"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("bridgeC"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("bridgeB"), isPresent());
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("bridgeB"), isPresent());
 
     ClassSubject cClassSubject = inspector.clazz(C.class);
     assertThat(cClassSubject, isPresent());
 
     ClassSubject axClassSubject = inspector.clazz(AWithRangedInvoke.class);
     assertThat(axClassSubject, isPresent());
-    assertThat(axClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(axClassSubject.uniqueMethodWithName("bridgeC"), isPresent());
+    assertThat(axClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(axClassSubject.uniqueMethodWithOriginalName("bridgeC"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
index b273533..af36954 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
@@ -71,7 +71,7 @@
               assertThat(baseClassSubject, isPresent());
 
               MethodSubject bridgeOnBaseMethodSubject =
-                  baseClassSubject.uniqueMethodWithName("bridge");
+                  baseClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnBaseMethodSubject, isPresent());
 
               // Inspect A. This should have the bridge method unless it is removed by the
@@ -79,7 +79,8 @@
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
 
-              MethodSubject bridgeOnAMethodSubject = aClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeOnAMethodSubject =
+                  aClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnAMethodSubject, notIf(isPresent(), removeBridgeMethodFromA));
 
               // Inspect B. This should not have a bridge method, as the bridge in C is not eligible
@@ -88,17 +89,19 @@
                   inspector.clazz(DescriptorUtils.descriptorToJavaType(TRANSFORMED_B_DESCRIPTOR));
               assertThat(bClassSubject, isPresent());
 
-              MethodSubject bridgeMethodSubject = bClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeMethodSubject =
+                  bClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeMethodSubject, isAbsent());
 
-              MethodSubject testMethodSubject = bClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject = bClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
 
               // Inspect C. The method C.bridge() is never eligible for hoisting.
               ClassSubject cClassSubject = inspector.clazz(C.class);
               assertThat(cClassSubject, isPresent());
 
-              MethodSubject bridgeOnCMethodSubject = cClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeOnCMethodSubject =
+                  cClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnCMethodSubject, isPresent());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
index bf958f8..34ea8d3 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
@@ -56,16 +56,16 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
 
     ClassSubject b1ClassSubject = inspector.clazz(B1.class);
     assertThat(b1ClassSubject, isPresent());
-    assertThat(b1ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+    assertThat(b1ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
 
     ClassSubject b2ClassSubject = inspector.clazz(B2.class);
     assertThat(b2ClassSubject, isPresent());
-    assertThat(b2ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+    assertThat(b2ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
index 458a8d2..13cd7b4 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
@@ -57,11 +57,11 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("bridge"), isPresent());
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
index 02c948c..dd3f482 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
@@ -55,16 +55,16 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(NonReboundBridgeHoistingTestClasses.getClassA());
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("bridge"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(NonReboundBridgeHoistingTestClasses.B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("bridge"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("bridge"), not(isPresent()));
 
     ClassSubject cClassSubject = inspector.clazz(C.class);
     assertThat(cClassSubject, isPresent());
-    assertThat(cClassSubject.uniqueMethodWithName("bridge"), not(isPresent()));
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("bridge"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
index ff05bfd..6264e0c 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
@@ -63,8 +63,8 @@
 
     ClassSubject b1ClassSubject = inspector.clazz(B.class);
     assertThat(b1ClassSubject, isPresent());
-    assertThat(b1ClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(b1ClassSubject.uniqueMethodWithName("bridge"), isPresent());
+    assertThat(b1ClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(b1ClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
index 2ac940a..156c74b 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
@@ -70,29 +70,29 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("superBridge"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
 
     ClassSubject b1ClassSubject = inspector.clazz(B1.class);
     assertThat(b1ClassSubject, isPresent());
-    assertThat(b1ClassSubject.uniqueMethodWithName("superBridge"), not(isPresent()));
-    assertThat(b1ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+    assertThat(b1ClassSubject.uniqueMethodWithOriginalName("superBridge"), not(isPresent()));
+    assertThat(b1ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
 
     ClassSubject b2ClassSubject = inspector.clazz(B2.class);
     assertThat(b2ClassSubject, isPresent());
-    assertThat(b2ClassSubject.uniqueMethodWithName("superBridge"), not(isPresent()));
-    assertThat(b2ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+    assertThat(b2ClassSubject.uniqueMethodWithOriginalName("superBridge"), not(isPresent()));
+    assertThat(b2ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
 
     ClassSubject b4ClassSubject = inspector.clazz(B4.class);
     assertThat(b4ClassSubject, isPresent());
-    assertThat(b4ClassSubject.uniqueMethodWithName("superBridge"), isPresent());
-    assertThat(b4ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+    assertThat(b4ClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+    assertThat(b4ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
 
     ClassSubject b5ClassSubject = inspector.clazz(B5.class);
     assertThat(b5ClassSubject, isPresent());
-    assertThat(b5ClassSubject.uniqueMethodWithName("superBridge"), isPresent());
-    assertThat(b5ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+    assertThat(b5ClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+    assertThat(b5ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
index 91ddda8..a353ff8 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
@@ -89,7 +89,8 @@
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
 
-              MethodSubject bridgeOnAMethodSubject = aClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeOnAMethodSubject =
+                  aClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnAMethodSubject, onlyIf(enableBridgeHoistingFromB, isPresent()));
 
               // Inspect B.
@@ -97,14 +98,16 @@
                   inspector.clazz(DescriptorUtils.descriptorToJavaType(TRANSFORMED_B_DESCRIPTOR));
               assertThat(bClassSubject, isPresent());
 
-              MethodSubject bridgeOnBMethodSubject = bClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeOnBMethodSubject =
+                  bClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnBMethodSubject, notIf(isPresent(), enableBridgeHoistingFromB));
 
               // Inspect C.
               ClassSubject cClassSubject = inspector.clazz(C.class);
               assertThat(cClassSubject, isPresent());
 
-              MethodSubject bridgeOnCMethodSubject = cClassSubject.uniqueMethodWithName("bridge");
+              MethodSubject bridgeOnCMethodSubject =
+                  cClassSubject.uniqueMethodWithOriginalName("bridge");
               assertThat(bridgeOnCMethodSubject, isAbsent());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java b/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
index 07d16af..0b4e818 100644
--- a/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
+++ b/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
@@ -113,7 +113,7 @@
               assertTrue(
                   inspector
                       .clazz(Runner.class)
-                      .uniqueMethodWithName("run")
+                      .uniqueMethodWithOriginalName("run")
                       .streamInstructions()
                       .anyMatch(i -> i.isConstClass(Runner.class.getTypeName())));
             });
diff --git a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
index 0bdb4f8..193e5b5 100644
--- a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
@@ -101,7 +101,8 @@
 
   private void checkPresenceOfDeserializedLambdas(CodeInspector inspector) {
     for (Class<?> clazz : getClasses()) {
-      MethodSubject method = inspector.clazz(clazz).uniqueMethodWithName("$deserializeLambda$");
+      MethodSubject method =
+          inspector.clazz(clazz).uniqueMethodWithOriginalName("$deserializeLambda$");
       assertEquals(
           "Unexpected status for $deserializedLambda$ on " + clazz.getSimpleName(),
           parameters.isCfRuntime(),
diff --git a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
index 255e2be..8b0251f 100644
--- a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
+++ b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
@@ -67,7 +67,8 @@
 
   private void checkPresenceOfDeserializedLambdas(CodeInspector inspector) {
     for (Class<?> clazz : getClasses()) {
-      MethodSubject method = inspector.clazz(clazz).uniqueMethodWithName("$deserializeLambda$");
+      MethodSubject method =
+          inspector.clazz(clazz).uniqueMethodWithOriginalName("$deserializeLambda$");
       assertEquals(
           "Unexpected status for $deserializedLambda$ on " + clazz.getSimpleName(),
           parameters.isCfRuntime(),
diff --git a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
index 7c9d4ac..5927841 100644
--- a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
@@ -72,7 +72,7 @@
     // L1: ; locals:
     // 11:   pop
     ClassSubject clazz = inspector.clazz("com.android.tools.r8.cf.TryRangeTestLimitRange");
-    CfCode cfCode = clazz.uniqueMethodWithName("main").getMethod().getCode().asCfCode();
+    CfCode cfCode = clazz.uniqueMethodWithOriginalName("main").getMethod().getCode().asCfCode();
     List<CfInstruction> instructions = cfCode.getInstructions();
     CfLabel startLabel = cfCode.getTryCatchRanges().get(0).start;
     int index = 0;
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
index b26a1cf..f41ac28 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
@@ -14,10 +14,12 @@
 
 import com.android.tools.r8.CompilationMode;
 import com.android.tools.r8.ExternalR8TestCompileResult;
+import com.android.tools.r8.JdkClassFileProvider;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.retrace.ProguardMapProducer;
@@ -56,6 +58,7 @@
     "}",
     "-allowaccessmodification"
   };
+  private static String HELLO_EXPECTED = StringUtils.lines("Hello, world");
 
   private static Pair<Path, Path> r8R8Debug;
   private static Pair<Path, Path> r8R8Release;
@@ -75,7 +78,9 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withCfRuntimes().build();
+    return getTestParameters()
+        .withCfRuntimesStartingFromIncluding(CfVm.getMinimumSystemVersion())
+        .build();
   }
 
   public BootstrapCurrentEqualityTest(TestParameters parameters) {
@@ -87,10 +92,11 @@
     final Path jar = testFolder.newFolder().toPath().resolve("out.jar");
     final Path map = testFolder.newFolder().toPath().resolve("out.map");
     if (testExternal) {
-      testForExternalR8(newTempFolder(), Backend.CF, TestRuntime.getCheckedInJdk9())
+      testForExternalR8(newTempFolder(), Backend.CF)
           .useR8WithRelocatedDeps()
           .setMode(mode)
           .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+          .addLibraryFiles(TestRuntime.getSystemRuntime().getJavaHome())
           .addKeepRuleFiles(MAIN_KEEP)
           .compile()
           .apply(c -> FileUtils.writeTextFile(map, c.getProguardMap()))
@@ -99,6 +105,7 @@
       testForR8(newTempFolder(), Backend.CF)
           .setMode(mode)
           .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+          .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
           .addKeepRuleFiles(MAIN_KEEP)
           .compile()
           .apply(c -> FileUtils.writeTextFile(map, c.getProguardMap()))
@@ -167,6 +174,7 @@
         testForExternalR8(parameters.getBackend(), parameters.getRuntime())
             .useProvidedR8(ToolHelper.R8LIB_JAR)
             .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+            .addLibraryFiles(parameters.asCfRuntime().getJavaHome())
             .addKeepRuleFiles(MAIN_KEEP)
             .setMode(CompilationMode.RELEASE)
             .compile()
@@ -176,6 +184,7 @@
             .useProvidedR8(ToolHelper.R8LIB_EXCLUDE_DEPS_JAR)
             .addR8ExternalDepsToClasspath()
             .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+            .addLibraryFiles(parameters.asCfRuntime().getJavaHome())
             .addKeepRuleFiles(MAIN_KEEP)
             .setMode(CompilationMode.RELEASE)
             .compile()
@@ -190,13 +199,15 @@
 
   @Test
   public void test() throws Exception {
-    Path helloJar = Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, "hello" + JAR_EXTENSION);
-    ProcessResult runResult = ToolHelper.runJava(helloJar, "hello.Hello");
-    assertEquals(0, runResult.exitCode);
-    compareR8(helloJar, runResult, KEEP_HELLO, "hello.Hello");
+    Path program = Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, "hello" + JAR_EXTENSION);
+    testForJvm()
+        .addProgramFiles(program)
+        .run(parameters.getRuntime(), HELLO_NAME)
+        .assertSuccessWithOutput(HELLO_EXPECTED)
+        .apply(r -> compareR8(program, HELLO_EXPECTED, KEEP_HELLO, HELLO_NAME));
   }
 
-  private void compareR8(Path program, ProcessResult runResult, String[] keep, String... args)
+  private void compareR8(Path program, String expectedOutput, String[] keep, String main)
       throws Exception {
     ExternalR8TestCompileResult runR8Debug =
         testForExternalR8(newTempFolder(), parameters.getBackend(), parameters.getRuntime())
@@ -205,7 +216,10 @@
             .addKeepRules(keep)
             .setMode(CompilationMode.DEBUG)
             .compile();
-    assertEquals(runResult.toString(), ToolHelper.runJava(runR8Debug.outputJar(), args).toString());
+    testForJvm()
+        .addProgramFiles(runR8Debug.outputJar())
+        .run(parameters.getRuntime(), main)
+        .assertSuccessWithOutput(expectedOutput);
     ExternalR8TestCompileResult runR8Release =
         testForExternalR8(newTempFolder(), parameters.getBackend(), parameters.getRuntime())
             .useR8WithRelocatedDeps()
@@ -213,8 +227,10 @@
             .addKeepRules(keep)
             .setMode(CompilationMode.RELEASE)
             .compile();
-    assertEquals(
-        runResult.toString(), ToolHelper.runJava(runR8Release.outputJar(), args).toString());
+    testForJvm()
+        .addProgramFiles(runR8Release.outputJar())
+        .run(parameters.getRuntime(), main)
+        .assertSuccessWithOutput(expectedOutput);
     RunR8AndCheck(r8R8Debug, program, runR8Debug, keep, CompilationMode.DEBUG);
     RunR8AndCheck(r8R8Debug, program, runR8Release, keep, CompilationMode.RELEASE);
     RunR8AndCheck(r8R8Release, program, runR8Debug, keep, CompilationMode.DEBUG);
diff --git a/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java b/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java
new file mode 100644
index 0000000..3bc8a3d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java
@@ -0,0 +1,169 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.cf.stringconcatfactory;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.DiagnosticsLevel;
+import com.android.tools.r8.DiagnosticsMatcher;
+import com.android.tools.r8.JdkClassFileProvider;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestState;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+import com.android.tools.r8.examples.JavaExampleClassProxy;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class StringConcatFactoryTest extends TestBase {
+
+  private static final String PKG = "stringconcatfactory";
+  private static final String EXAMPLE = "examplesJava9/" + PKG;
+  private final JavaExampleClassProxy MAIN =
+      new JavaExampleClassProxy(EXAMPLE, PKG + "/StringConcatFactoryUsage");
+
+  static final String EXPECTED = StringUtils.lines("Hello 0");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+  }
+
+  public StringConcatFactoryTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private void checkInvokeDynamic(CodeInspector inspector) {
+    assertEquals(
+        parameters.isCfRuntime(),
+        inspector
+            .clazz(MAIN.typeName())
+            .uniqueMethodWithOriginalName("main")
+            .streamInstructions()
+            .anyMatch(InstructionSubject::isInvokeDynamic));
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClassFileData(MAIN.bytes())
+        .run(parameters.getRuntime(), MAIN.typeName())
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkInvokeDynamic);
+  }
+
+  @Test
+  public void testJdk8NoIgnoreR8() throws Exception {
+    R8FullTestBuilder builder =
+        testForR8(parameters.getBackend())
+            .setMinApi(parameters.getApiLevel())
+            .addProgramClassFileData(MAIN.bytes())
+            // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+            .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+            .addKeepMainRule(MAIN.typeName());
+    R8TestCompileResult compileResult;
+    try {
+      compileResult =
+          builder.compileWithExpectedDiagnostics(
+              diagnostics -> {
+                if (parameters.isDexRuntime()) {
+                  diagnostics.assertNoMessages();
+                } else {
+                  diagnostics.assertErrorsMatch(
+                      DiagnosticsMatcher.diagnosticType(MissingDefinitionsDiagnostic.class));
+                  diagnostics.assertOnlyErrors();
+                }
+              });
+    } catch (CompilationFailedException e) {
+      assertTrue(parameters.isCfRuntime());
+      return;
+    }
+    assertTrue(parameters.isDexRuntime());
+    compileResult
+        .run(parameters.getRuntime(), MAIN.typeName())
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkInvokeDynamic);
+  }
+
+  @Test
+  public void testJdk8WithIgnoreR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClassFileData(MAIN.bytes())
+        // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+        .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+        .addKeepMainRule(MAIN.typeName())
+        .applyIf(
+            parameters.isCfRuntime(), b -> b.addDontWarn("java.lang.invoke.StringConcatFactory"))
+        .compile()
+        .run(parameters.getRuntime(), MAIN.typeName())
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkInvokeDynamic);
+  }
+
+  @Test
+  public void testJdk8WithMapDiagnostic() throws Exception {
+    TestDiagnosticMessagesImpl handler =
+        new TestDiagnosticMessagesImpl() {
+          @Override
+          public DiagnosticsLevel modifyDiagnosticsLevel(
+              DiagnosticsLevel level, Diagnostic diagnostic) {
+            if (diagnostic instanceof MissingDefinitionsDiagnostic) {
+              return DiagnosticsLevel.WARNING;
+            }
+            return super.modifyDiagnosticsLevel(level, diagnostic);
+          }
+        };
+    R8FullTestBuilder.create(new TestState(temp, handler), parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClassFileData(MAIN.bytes())
+        // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+        .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+        .addKeepMainRule(MAIN.typeName())
+        .allowDiagnosticWarningMessages(parameters.isCfRuntime())
+        .compileWithExpectedDiagnostics(
+            diagnostics -> {
+              if (parameters.isDexRuntime()) {
+                diagnostics.assertNoMessages();
+              } else {
+                diagnostics
+                    .assertWarningsMatch(
+                        DiagnosticsMatcher.diagnosticType(MissingDefinitionsDiagnostic.class))
+                    .assertOnlyWarnings();
+              }
+            })
+        .run(parameters.getRuntime(), MAIN.typeName())
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkInvokeDynamic);
+  }
+
+  @Test
+  public void testSystemJdkNoIgnoreClassesR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClassFileData(MAIN.bytes())
+        // The system runtime has StringConcatFactory so link to its bootclasspath.
+        .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
+        .addKeepMainRule(MAIN.typeName())
+        .run(parameters.getRuntime(), MAIN.typeName())
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(this::checkInvokeDynamic);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java b/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
index f19d1c1..ad0af4b 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
@@ -88,8 +88,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject logClassSubject = inspector.clazz(Log.class);
     assertThat(logClassSubject, isPresent());
-    assertThat(logClassSubject.uniqueMethodWithName("foo"), isPresent());
-    assertThat(logClassSubject.uniqueMethodWithName("bar"), not(isPresent()));
+    assertThat(logClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+    assertThat(logClassSubject.uniqueMethodWithOriginalName("bar"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
index 0b2fa97..fe6cd7e 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
@@ -15,8 +15,6 @@
 import com.android.tools.r8.NoVerticalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.checkdiscarded.CheckClassDiscardedEntirelyTest.Main;
-import com.android.tools.r8.checkdiscarded.CheckClassDiscardedEntirelyTest.Secret;
 import com.android.tools.r8.errors.CheckDiscardDiagnostic;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -105,9 +103,11 @@
                       ClassSubject publicClassSubject = inspector.clazz(Public.class);
                       assertThat(publicClassSubject, isPresent());
                       assertThat(
-                          publicClassSubject.uniqueMethodWithName("printPublic"), isPresent());
+                          publicClassSubject.uniqueMethodWithOriginalName("printPublic"),
+                          isPresent());
                       assertThat(
-                          publicClassSubject.uniqueMethodWithName("printPublicAllowInlining"),
+                          publicClassSubject.uniqueMethodWithOriginalName(
+                              "printPublicAllowInlining"),
                           isAbsent());
 
                       assertThat(inspector.clazz(Secret.class), isAbsent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
index 269b793..05698dc 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
@@ -12,9 +12,6 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.A;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.B;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.Main;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.FieldSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -45,23 +42,23 @@
               assertThat(codeInspector.clazz(B.class), isAbsent());
               assertThat(codeInspector.clazz(C.class), isPresent());
 
-              FieldSubject v1Subject = aClassSubject.uniqueFieldWithName("v1");
-              FieldSubject v2Subject = aClassSubject.uniqueFieldWithName("v2");
+              FieldSubject v1Subject = aClassSubject.uniqueFieldWithOriginalName("v1");
+              FieldSubject v2Subject = aClassSubject.uniqueFieldWithOriginalName("v2");
 
-              MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("getAV1");
+              MethodSubject methodSubject = aClassSubject.uniqueMethodWithOriginalName("getAV1");
               assertThat(methodSubject, isPresent());
               assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
 
-              methodSubject = aClassSubject.uniqueMethodWithName("getAV2");
+              methodSubject = aClassSubject.uniqueMethodWithOriginalName("getAV2");
               assertThat(methodSubject, isPresent());
               assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
 
               // The fields v1 and v2 are swapped, because their access modifiers are swapped.
-              methodSubject = aClassSubject.uniqueMethodWithName("getBV1");
+              methodSubject = aClassSubject.uniqueMethodWithOriginalName("getBV1");
               assertThat(methodSubject, isPresent());
               assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
 
-              methodSubject = aClassSubject.uniqueMethodWithName("getBV2");
+              methodSubject = aClassSubject.uniqueMethodWithOriginalName("getBV2");
               assertThat(methodSubject, isPresent());
               assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
             });
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
index 93bfcef..a4dd321 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
@@ -40,7 +40,7 @@
               ClassSubject aClassSubject = codeInspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               FieldSubject classIdFieldSubject =
-                  aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+                  aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
               assertThat(classIdFieldSubject, isPresent());
 
               MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
index e5a169b..9f0bb44 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
@@ -49,7 +49,7 @@
               ClassSubject aClassSubject = codeInspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               FieldSubject classIdFieldSubject =
-                  aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+                  aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
               assertThat(classIdFieldSubject, isPresent());
 
               MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
index 61432d2..38119c1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
@@ -40,7 +40,7 @@
               ClassSubject aClassSubject = codeInspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               FieldSubject classIdFieldSubject =
-                  aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+                  aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
               assertThat(classIdFieldSubject, isPresent());
 
               MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
index e688559..3f32311 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
@@ -42,11 +42,11 @@
               ClassSubject cClassSubject = codeInspector.clazz(C.class);
               assertThat(codeInspector.clazz(C.class), isPresent());
 
-              FieldSubject fieldSubject = cClassSubject.uniqueFieldWithName("fieldB");
+              FieldSubject fieldSubject = cClassSubject.uniqueFieldWithOriginalName("fieldB");
               assertThat(fieldSubject, isPresent());
               assertThat(fieldSubject, isFieldOfType(aClassSubject.getDexProgramClass().getType()));
 
-              fieldSubject = cClassSubject.uniqueFieldWithName("fieldArrayB");
+              fieldSubject = cClassSubject.uniqueFieldWithOriginalName("fieldArrayB");
               assertThat(fieldSubject, isPresent());
               assertTrue(fieldSubject.getDexField().type.isArrayType());
               assertThat(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
index 817c786..1c03f26 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
@@ -42,7 +42,7 @@
               ClassSubject aClassSubject = codeInspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               FieldSubject classIdFieldSubject =
-                  aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+                  aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
               assertThat(classIdFieldSubject, isPresent());
 
               MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
index 5e95a1e..8709f49 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
@@ -47,7 +47,7 @@
               ClassSubject classSubject = inspector.clazz(A.class);
               assertThat(classSubject, isPresent());
 
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("foo$bridge");
+              MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("foo$bridge");
               assertThat(methodSubject, isPresent());
               assertFalse(methodSubject.isFinal());
             })
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
index 6287174..b0ef0f0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
@@ -46,7 +46,7 @@
               ClassSubject classSubject = inspector.clazz(A.class);
               assertThat(classSubject, isPresent());
 
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("foo");
+              MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("foo");
               assertThat(methodSubject, isPresent());
               assertFalse(methodSubject.isFinal());
             })
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
index d96c16c..3790be6 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
@@ -57,13 +57,15 @@
             inspector -> {
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
-              assertThat(iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPublic()));
+              assertThat(
+                  iClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isPublic()));
 
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertThat(aClassSubject, not(isImplementing(iClassSubject)));
               assertThat(
-                  aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+                  aClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), isPackagePrivate()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()", "Y.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
index 8093d0c..79b840f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
@@ -56,13 +56,15 @@
             inspector -> {
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
-              assertThat(iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPublic()));
+              assertThat(
+                  iClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isPublic()));
 
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertThat(aClassSubject, isExtending(iClassSubject));
               assertThat(
-                  aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+                  aClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), isPackagePrivate()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()", "B.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
index 4d793a4..3b1e8c1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
@@ -47,7 +47,7 @@
               assertThat(aClassSubject, isPresent());
 
               MethodSubject synchronizedMethodSubject =
-                  aClassSubject.uniqueMethodWithName("m$bridge");
+                  aClassSubject.uniqueMethodWithOriginalName("m$bridge");
               assertThat(synchronizedMethodSubject, isPresent());
               assertTrue(synchronizedMethodSubject.getAccessFlags().isStrict());
 
@@ -55,7 +55,7 @@
               assertThat(cClassSubject, isPresent());
 
               MethodSubject unsynchronizedMethodSubject =
-                  cClassSubject.uniqueMethodWithName("m$bridge");
+                  cClassSubject.uniqueMethodWithOriginalName("m$bridge");
               assertThat(unsynchronizedMethodSubject, isPresent());
               assertFalse(unsynchronizedMethodSubject.getAccessFlags().isStrict());
             })
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
index 4811a41..374e568 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
@@ -47,7 +47,7 @@
               assertThat(aClassSubject, isPresent());
 
               MethodSubject synchronizedMethodSubject =
-                  aClassSubject.uniqueMethodWithName("m$bridge");
+                  aClassSubject.uniqueMethodWithOriginalName("m$bridge");
               assertThat(synchronizedMethodSubject, isPresent());
               assertTrue(synchronizedMethodSubject.isSynchronized());
 
@@ -55,7 +55,7 @@
               assertThat(cClassSubject, isPresent());
 
               MethodSubject unsynchronizedMethodSubject =
-                  cClassSubject.uniqueMethodWithName("m$bridge");
+                  cClassSubject.uniqueMethodWithOriginalName("m$bridge");
               assertThat(unsynchronizedMethodSubject, isPresent());
               assertFalse(unsynchronizedMethodSubject.isSynchronized());
             })
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
index 07f3fce..3417654 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
@@ -47,12 +47,12 @@
               ClassSubject parentClassSubject = codeInspector.clazz(Parent.class);
               assertThat(parentClassSubject, isPresent());
               // Parent#foo is renamed to Parent#foo1 to prevent collision.
-              assertThat(parentClassSubject.uniqueMethodWithName("foo$1"), isPresent());
+              assertThat(parentClassSubject.uniqueMethodWithOriginalName("foo$1"), isPresent());
 
               ClassSubject cClassSubject = codeInspector.clazz(C.class);
               assertThat(cClassSubject, isPresent());
               // C#foo is not renamed to match interface.
-              assertThat(cClassSubject.uniqueMethodWithName("foo"), isPresent());
+              assertThat(cClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
 
               ClassSubject iClassSubject = codeInspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
index 43bbf33..e346353 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
@@ -52,7 +52,7 @@
               ClassSubject cClassSubject = codeInspector.clazz(C.class);
               assertThat(cClassSubject, isPresent());
               // C#foo is not renamed to match interface.
-              assertThat(cClassSubject.uniqueMethodWithName("foo"), isPresent());
+              assertThat(cClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
 
               ClassSubject iClassSubject = codeInspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
index f58252e..d904b01 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
@@ -58,13 +58,14 @@
             inspector -> {
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
-              assertThat(iClassSubject.uniqueMethodWithName("m"), isAbsent());
+              assertThat(iClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
 
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertThat(aClassSubject, isImplementing(iClassSubject));
               assertThat(
-                  aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+                  aClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), isPackagePrivate()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()", "B.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
index 420ccaa..d4094c5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
@@ -59,12 +59,13 @@
             inspector -> {
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
-              assertThat(iClassSubject.uniqueMethodWithName("m"), isAbsent());
+              assertThat(iClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
 
               ClassSubject a0ClassSubject = inspector.clazz(A0.class);
               assertThat(a0ClassSubject, isPresent());
               assertThat(
-                  a0ClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+                  a0ClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), isPackagePrivate()));
 
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java b/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
index 5ab767d..6156017 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
@@ -70,10 +70,10 @@
 
     ClassSubject boxImpl = inspector.clazz(BoxImpl.class);
     assertThat(boxImpl, isPresent());
-    FieldSubject storage = boxImpl.uniqueFieldWithName("_storage");
+    FieldSubject storage = boxImpl.uniqueFieldWithOriginalName("_storage");
     assertThat(storage, isPresent());
 
-    MethodSubject set = boxImpl.uniqueMethodWithName("set");
+    MethodSubject set = boxImpl.uniqueMethodWithOriginalName("set");
     assertThat(set, isPresent());
 
     assertEquals(
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
index da6cb32..1f9e6c7 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
@@ -53,7 +53,6 @@
 import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;
-import java.util.function.Function;
 import java.util.function.Predicate;
 import org.junit.Assume;
 import org.junit.Test;
@@ -540,7 +539,7 @@
                             .toString()
                             .equals("java.lang.String classmerging.ProguardFieldMapTest$A.f")
                         && fieldNaming
-                            .computeResidualSignature(Function.identity())
+                            .getResidualSignature()
                             .toString()
                             .equals("java.lang.String f")));
   }
@@ -588,10 +587,7 @@
                     methodNaming
                         .getOriginalSignature()
                         .toString()
-                        .equals(
-                            methodNaming
-                                .computeResidualSignature(Function.identity())
-                                .toString())));
+                        .equals(methodNaming.getResidualSignature().toString())));
 
     // Try with vertical class merging.
     Set<String> preservedClassNames =
@@ -624,7 +620,7 @@
                             .toString()
                             .equals("void classmerging.ProguardMethodMapTest$A.method()")
                         && methodNaming
-                            .computeResidualSignature(Function.identity())
+                            .getResidualSignature()
                             .toString()
                             .equals("void method$classmerging$ProguardMethodMapTest$A()")));
   }
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
index d4d1355..69d794e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
@@ -56,7 +56,7 @@
               assertEquals(
                   "<T:Ljava/lang/Object;>L" + binaryName(A.class) + "<Ljava/lang/Object;>;",
                   classSubject.getFinalSignatureAttribute());
-              MethodSubject bar = classSubject.uniqueMethodWithName("bar");
+              MethodSubject bar = classSubject.uniqueMethodWithOriginalName("bar");
               assertThat(bar, isPresentAndRenamed());
               assertEquals("(TT;)V", bar.getFinalSignatureAttribute());
               // The NeverInline is transferred to the private vertically merged method but also
diff --git a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
index dba64d3..a733112 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
@@ -91,11 +91,11 @@
   }
 
   private static void assertBarGetInstanceIsNotInlined(CodeInspector inspector) {
-    assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithName("instance").isPresent());
+    assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("instance").isPresent());
     assertTrue(
         inspector
             .clazz(MAIN_CLASS)
-            .uniqueMethodWithName("main")
+            .uniqueMethodWithOriginalName("main")
             .streamInstructions()
             .anyMatch(i -> i.isInvoke() && i.getMethod().qualifiedName().contains("instance")));
   }
@@ -154,8 +154,9 @@
               assertTrue(inspector.clazz(MAIN_CLASS).isPresent());
               assertTrue(inspector.clazz(BAR_CLASS).isPresent());
               assertBarGetInstanceIsNotInlined(inspector);
-              assertTrue(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i").isPresent());
-              assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithName("<init>").isPresent());
+              assertTrue(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i").isPresent());
+              assertTrue(
+                  inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("<init>").isPresent());
             })
         .run(parameters.getRuntime(), MAIN_CLASS)
         .assertSuccessWithOutput(EXPECTED);
@@ -184,7 +185,7 @@
               assertTrue(inspector.clazz(BAR_CLASS).isPresent());
               assertBarGetInstanceIsNotInlined(inspector);
               assertThat(inspector.clazz(BAR_CLASS).init(), isPresent());
-              assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i"), isPresent());
+              assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i"), isPresent());
             });
   }
 
@@ -256,13 +257,13 @@
               // Bar is renamed but its member names are kept.
               ClassSubject bar = inspector.clazz(BAR_CLASS);
               assertTrue(bar.isRenamed());
-              FieldSubject barI = bar.uniqueFieldWithName("i");
+              FieldSubject barI = bar.uniqueFieldWithOriginalName("i");
               assertTrue(barI.isPresent());
               assertFalse(barI.isRenamed());
-              MethodSubject barInit = bar.uniqueMethodWithName("<init>");
+              MethodSubject barInit = bar.uniqueMethodWithOriginalName("<init>");
               assertTrue(barInit.isPresent());
               assertFalse(barInit.isRenamed());
-              MethodSubject barInstance = bar.uniqueMethodWithName("instance");
+              MethodSubject barInstance = bar.uniqueMethodWithOriginalName("instance");
               assertTrue(barInstance.isPresent());
               assertFalse(barInstance.isRenamed());
             })
@@ -296,8 +297,9 @@
               assertTrue(inspector.clazz(MAIN_CLASS).isPresent());
               assertTrue(inspector.clazz(BAR_CLASS).isPresent());
               assertBarGetInstanceIsNotInlined(inspector);
-              assertThat(inspector.clazz(BAR_CLASS).uniqueMethodWithName("<init>"), isPresent());
-              assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i"), isPresent());
+              assertThat(
+                  inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("<init>"), isPresent());
+              assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i"), isPresent());
             });
   }
 
@@ -356,10 +358,10 @@
               assertBarGetInstanceIsNotInlined(inspector);
               ClassSubject bar = inspector.clazz(BAR_CLASS);
               assertTrue(bar.isPresent());
-              assertTrue(bar.uniqueMethodWithName("instance").isPresent());
+              assertTrue(bar.uniqueMethodWithOriginalName("instance").isPresent());
               // Reflected on fields are not kept.
-              assertFalse(bar.uniqueMethodWithName("<init>").isPresent());
-              assertFalse(bar.uniqueFieldWithName("i").isPresent());
+              assertFalse(bar.uniqueMethodWithOriginalName("<init>").isPresent());
+              assertFalse(bar.uniqueFieldWithOriginalName("i").isPresent());
             })
         .run(parameters.getRuntime(), MAIN_CLASS)
         // Keeping the instance and its accessed members does not keep the reflected <init> and i.
@@ -414,9 +416,9 @@
               ClassSubject bar = inspector.clazz(BAR_CLASS);
               assertTrue(bar.isPresent());
               assertTrue(bar.isRenamed());
-              assertFalse(bar.uniqueFieldWithName("i").isPresent());
-              assertFalse(bar.uniqueMethodWithName("<init>").isPresent());
-              MethodSubject barInstance = bar.uniqueMethodWithName("instance");
+              assertFalse(bar.uniqueFieldWithOriginalName("i").isPresent());
+              assertFalse(bar.uniqueMethodWithOriginalName("<init>").isPresent());
+              MethodSubject barInstance = bar.uniqueMethodWithOriginalName("instance");
               assertTrue(barInstance.isPresent());
               assertFalse(barInstance.isRenamed());
             })
diff --git a/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java b/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
index 009cf9f..70aaa93 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
@@ -78,8 +78,8 @@
             inspector -> {
               ClassSubject aClass = inspector.clazz(A.class);
               assertThat(aClass, isPresentAndRenamed());
-              assertThat(aClass.uniqueFieldWithName("foo"), isPresentAndNotRenamed());
-              assertThat(aClass.uniqueMethodWithName("foo"), isPresentAndNotRenamed());
+              assertThat(aClass.uniqueFieldWithOriginalName("foo"), isPresentAndNotRenamed());
+              assertThat(aClass.uniqueMethodWithOriginalName("foo"), isPresentAndNotRenamed());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello World!", "Hello World!");
diff --git a/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java b/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
index 0f82a73..4c7b46c 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
@@ -41,21 +41,22 @@
           RR extends TestRunResult<RR>,
           T extends TestShrinkerBuilder<C, B, CR, RR, T>>
       void testKeepIsDisjunction(TestShrinkerBuilder<C, B, CR, RR, T> builder) throws Exception {
-        builder
-            .addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
-            .addKeepRules("-keep class * { public long foo(); public long bar(); }")
-            .compile()
-            .inspect(inspector -> {
+    builder
+        .addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
+        .addKeepRules("-keep class * { public long foo(); public long bar(); }")
+        .compile()
+        .inspect(
+            inspector -> {
               ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
               ClassSubject justFoo = inspector.clazz(JustFoo.class);
               ClassSubject justBar = inspector.clazz(JustBar.class);
               assertTrue(bothFooAndBar.isPresent());
-              assertTrue(bothFooAndBar.uniqueMethodWithName("foo").isPresent());
-              assertTrue(bothFooAndBar.uniqueMethodWithName("bar").isPresent());
+              assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("foo").isPresent());
+              assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("bar").isPresent());
               assertTrue(justFoo.isPresent());
-              assertTrue(justFoo.uniqueMethodWithName("foo").isPresent());
+              assertTrue(justFoo.uniqueMethodWithOriginalName("foo").isPresent());
               assertTrue(justBar.isPresent());
-              assertTrue(justBar.uniqueMethodWithName("bar").isPresent());
+              assertTrue(justBar.uniqueMethodWithOriginalName("bar").isPresent());
             });
   }
 
@@ -86,16 +87,17 @@
         .addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
         .addKeepRules("-keepclasseswithmembers class * { public long foo(); public long bar(); }")
         .compile()
-        .inspect(inspector -> {
-          ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
-          ClassSubject justFoo = inspector.clazz(JustFoo.class);
-          ClassSubject justBar = inspector.clazz(JustBar.class);
-          assertTrue(bothFooAndBar.isPresent());
-          assertTrue(bothFooAndBar.uniqueMethodWithName("foo").isPresent());
-          assertTrue(bothFooAndBar.uniqueMethodWithName("bar").isPresent());
-          assertFalse(justFoo.isPresent());
-          assertFalse(justBar.isPresent());
-        });
+        .inspect(
+            inspector -> {
+              ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
+              ClassSubject justFoo = inspector.clazz(JustFoo.class);
+              ClassSubject justBar = inspector.clazz(JustBar.class);
+              assertTrue(bothFooAndBar.isPresent());
+              assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("foo").isPresent());
+              assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("bar").isPresent());
+              assertFalse(justFoo.isPresent());
+              assertFalse(justBar.isPresent());
+            });
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java b/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
index 5a17702..11c8aed 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
@@ -75,7 +75,7 @@
     assertTrue(
         new CodeInspector(output)
             .clazz(MockClassWithAssertion.class)
-            .uniqueMethodWithName("main")
+            .uniqueMethodWithOriginalName("main")
             .streamInstructions()
             .anyMatch(this::invokesAssertionHandler));
   }
diff --git a/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java b/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
index 962cec0..f09071f 100644
--- a/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
@@ -93,7 +93,7 @@
     ClassSubject testA = inspector.clazz(TestA.class);
     assertThat(testA, isPresent());
 
-    MethodSubject foo = testA.uniqueMethodWithName("foo");
+    MethodSubject foo = testA.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     AnnotationSubject annotation = foo.annotation(TestKeep.class.getName());
     assertThat(annotation, isPresent());
@@ -110,17 +110,17 @@
     ClassSubject testB = inspector.clazz(TestB.class);
     assertThat(testB, isPresent());
 
-    FieldSubject instance = testB.uniqueFieldWithName("instance");
+    FieldSubject instance = testB.uniqueFieldWithOriginalName("instance");
     assertThat(instance, isPresent());
     annotation = instance.annotation(TestKeep.class.getName());
     assertThat(annotation, isPresent());
 
-    foo = testB.uniqueMethodWithName("foo");
+    foo = testB.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     annotation = foo.annotation(TestKeep.class.getName());
     assertThat(annotation, isPresent());
 
-    MethodSubject bar = testB.uniqueMethodWithName("bar");
+    MethodSubject bar = testB.uniqueMethodWithOriginalName("bar");
     assertThat(bar, isPresent());
     annotation = bar.annotation(TestKeep.class.getName());
     assertThat(annotation, isPresent());
diff --git a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
index a8eb9cc..053f4b3 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
@@ -67,7 +67,7 @@
     result.inspect(
         inspector -> {
           DexEncodedMethod method =
-              inspector.clazz(ClassA.class).uniqueMethodWithName("call").getMethod();
+              inspector.clazz(ClassA.class).uniqueMethodWithOriginalName("call").getMethod();
           DexDebugInfo debugInfo = method.getCode().asDexCode().getDebugInfo();
           assertNull(debugInfo);
         });
diff --git a/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
index f3a22bf..c6f0994 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
@@ -137,13 +137,13 @@
   private void checkNoDebugInfo(CodeInspector inspector, int expectedMethodsInMain) {
     ClassSubject clazz = inspector.clazz(MAIN);
     assertEquals(expectedMethodsInMain, clazz.allMethods().size());
-    MethodSubject main = clazz.uniqueMethodWithName("main");
+    MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
     assertNull(main.getMethod().getCode().asDexCode().getDebugInfo());
   }
 
   private void checkHasLineNumberInfo(CodeInspector inspector) {
     ClassSubject clazz = inspector.clazz(MAIN);
-    MethodSubject main = clazz.uniqueMethodWithName("main");
+    MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
     List<DexDebugEntry> entries =
         new DexDebugEntryBuilder(main.getMethod(), inspector.getFactory()).build();
     Set<Integer> lines = entries.stream().map(e -> e.line).collect(Collectors.toSet());
diff --git a/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java b/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
index ccdac2d..377df99 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
@@ -41,7 +41,8 @@
         .run(parameters.getRuntime(), TestClass.class)
         .inspect(
             inspector -> {
-              MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithName("foo");
+              MethodSubject foo =
+                  inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("foo");
               assertTrue(
                   foo.getLineNumberTable().getLines().toString(),
                   foo.getLineNumberTable().getLines().contains(11));
diff --git a/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java b/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
index 596707f..46d76ca 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
@@ -38,7 +38,7 @@
                     1,
                     inspector
                         .clazz(TestClass.class)
-                        .uniqueMethodWithName("testLoopPhiWithNullFirstInput")
+                        .uniqueMethodWithOriginalName("testLoopPhiWithNullFirstInput")
                         .streamInstructions()
                         .filter(InstructionSubject::isGoto)
                         .count()));
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
index f83d077..c577259 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
@@ -67,9 +67,9 @@
               assertThat(stackTrace, isSame(expectedStackTrace));
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
-              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
                   notIf(hasLineNumberTable(), parameters.isDexRuntime()));
             });
   }
@@ -91,9 +91,9 @@
               assertThat(stackTrace, isSame(expectedStackTrace));
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
-              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
                   notIf(hasLineNumberTable(), parameters.isDexRuntime()));
             });
   }
@@ -115,9 +115,9 @@
               assertThat(stackTrace, isSame(expectedStackTrace));
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
-              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
                   notIf(hasLineNumberTable(), parameters.isDexRuntime()));
             });
   }
@@ -139,9 +139,9 @@
               assertThat(stackTrace, isSame(expectedStackTrace));
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
-              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
                   // TODO(b/146565491): Update to allow dropping the table once supported by ART.
                   hasLineNumberTable());
             });
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
index d7a5df3..542cfb6 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
@@ -70,10 +70,11 @@
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForMultipleInvokes"),
+                  mainSubject.uniqueMethodWithOriginalName(
+                      "shouldRemoveLineNumberForMultipleInvokes"),
                   notIf(hasLineNumberTable(), parameters.isDexRuntime()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("main"),
+                  mainSubject.uniqueMethodWithOriginalName("main"),
                   notIf(hasLineNumberTable(), parameters.isDexRuntime()));
             });
   }
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
index bc0d012..c547357 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
@@ -67,9 +67,9 @@
               assertThat(stackTrace, isSame(expectedStackTrace));
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
-              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldNotRemoveLineNumberForInline"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldNotRemoveLineNumberForInline"),
                   notIf(
                       hasLineNumberTable(),
                       parameters.isDexRuntime()
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
index b881f55..8076acf 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
@@ -92,7 +92,7 @@
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresent());
               assertThat(
-                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumber"),
+                  mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumber"),
                   notIf(hasLineNumberTable(), canSingleLineDebugInfoBeDiscarded()));
             });
   }
diff --git a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
index 0bbdf46..0cc3e5b 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
@@ -57,7 +57,7 @@
               // normal encodings.
               DexDebugInfo shared = null;
               for (String name : METHODS) {
-                DexEncodedMethod method = clazz.uniqueMethodWithName(name).getMethod();
+                DexEncodedMethod method = clazz.uniqueMethodWithOriginalName(name).getMethod();
                 DexDebugInfo debugInfo = method.getCode().asDexCode().getDebugInfo();
                 assertTrue(debugInfo.isPcBasedInfo());
                 // The DEX parser should allocate the same shared instance to each method.
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
index 23436d3..9fd70ef 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
@@ -75,7 +75,7 @@
             assertEquals(
                 testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
             assertThat(
-                testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
+                testClassSubject.uniqueMethodWithOriginalName(enclosingMethod.name.toString()),
                 isPresent());
           }
         });
@@ -90,8 +90,8 @@
     String outer = DesugarLambdaWithAnonymousClass.class.getTypeName();
     ClassSubject testClass = inspector.clazz(outer + "$TestClass");
     assertThat(testClass, isPresent());
-    assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
-    assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
+    assertThat(testClass.uniqueMethodWithOriginalName("lambda$test$0"), isPresent());
+    assertThat(testClass.uniqueMethodWithOriginalName("lambda$testStatic$1"), isPresent());
     assertThat(inspector.clazz(outer + "$TestClass$1"), isPresent());
     assertThat(inspector.clazz(outer + "$TestClass$2"), isPresent());
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
index 60fde2f..76eb3d7 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
@@ -73,7 +73,7 @@
             assertEquals(
                 testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
             assertThat(
-                testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
+                testClassSubject.uniqueMethodWithOriginalName(enclosingMethod.name.toString()),
                 isPresent());
           }
         });
@@ -88,8 +88,8 @@
     String outer = DesugarLambdaWithLocalClass.class.getTypeName();
     ClassSubject testClass = inspector.clazz(outer + "$TestClass");
     assertThat(testClass, isPresent());
-    assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
-    assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
+    assertThat(testClass.uniqueMethodWithOriginalName("lambda$test$0"), isPresent());
+    assertThat(testClass.uniqueMethodWithOriginalName("lambda$testStatic$1"), isPresent());
     assertThat(inspector.clazz(outer + "$TestClass$1MyConsumerImpl"), isPresent());
     assertThat(inspector.clazz(outer + "$TestClass$2MyConsumerImpl"), isPresent());
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
index 9444833..b1fae08 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
@@ -61,7 +61,8 @@
   }
 
   private void checkBackportingNotRequired(CodeInspector inspector) {
-    MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+    MethodSubject methodSubject =
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main");
     if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
       CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
       assertTrue(code.getInstructions().stream().noneMatch(this::isCfLAdd));
@@ -73,7 +74,8 @@
   }
 
   private void checkBackportingRequired(CodeInspector inspector) {
-    MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+    MethodSubject methodSubject =
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main");
     if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
       CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
       assertTrue(code.getInstructions().stream().anyMatch(this::isCfLAdd));
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
index 8524f5d..f90490d 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
@@ -140,7 +140,9 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(TestRunner.class).uniqueMethodWithName(jacocoBootstrapMethodName),
+                  inspector
+                      .clazz(TestRunner.class)
+                      .uniqueMethodWithOriginalName(jacocoBootstrapMethodName),
                   isAbsent());
             })
         .assertSuccessWithOutputLines("No " + jacocoBootstrapMethodName + " method");
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 6b61085..872ca85 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
@@ -80,7 +80,8 @@
     if (compilationSpecification.isProgramShrink()) {
       return;
     }
-    MethodSubject direct = inspector.clazz(Executor.class).uniqueMethodWithName("directTypes");
+    MethodSubject direct =
+        inspector.clazz(Executor.class).uniqueMethodWithOriginalName("directTypes");
     if (libraryDesugaringSpecification.hasEmulatedInterfaceDesugaring(parameters)) {
       assertTrue(
           direct
@@ -95,7 +96,7 @@
       assertTrue(direct.streamInstructions().noneMatch(instr -> instr.toString().contains("$-EL")));
     }
     MethodSubject inherited =
-        inspector.clazz(Executor.class).uniqueMethodWithName("inheritedTypes");
+        inspector.clazz(Executor.class).uniqueMethodWithOriginalName("inheritedTypes");
     if (!libraryDesugaringSpecification.hasEmulatedInterfaceDesugaring(parameters)) {
       assertTrue(
           inherited.streamInstructions().noneMatch(instr -> instr.toString().contains("$-EL")));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
index 8d8f669..d6ede8b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
@@ -118,7 +118,7 @@
     }
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    MethodSubject main = classSubject.uniqueMethodWithName("main");
+    MethodSubject main = classSubject.uniqueMethodWithOriginalName("main");
     Set<String> foundInvokeHolders =
         main.streamInstructions()
             .filter(InstructionSubject::isInvoke)
@@ -177,7 +177,7 @@
             .isGreaterThanOrEqualTo(TestBase.apiLevelWithDefaultInterfaceMethodsSupport())
         || isR8) {
       assertThat(
-          inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithName("query"),
+          inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithOriginalName("query"),
           not(isPresent()));
     } else {
       assertThat(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
index 2f146bb..db9a6f1 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
@@ -69,7 +69,7 @@
     assertEquals(
         function,
         classSubject
-            .uniqueMethodWithName("applyFunction")
+            .uniqueMethodWithOriginalName("applyFunction")
             .getMethod()
             .getReference()
             .proto
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
index 23a13b6..6951b62 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
@@ -65,7 +65,7 @@
     assertThat(classSubject, isPresent());
     Iterator<InvokeInstructionSubject> iterator =
         classSubject
-            .uniqueMethodWithName("main")
+            .uniqueMethodWithOriginalName("main")
             .iterateInstructions(InstructionSubject::isInvokeStatic);
     assertTrue(iterator.next().holder().is("j$.util.Optional"));
     assertTrue(iterator.next().holder().is("j$.util.Optional"));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
index a3f36be..0cf1b01 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
@@ -64,8 +64,10 @@
   }
 
   private void assertNoForwardingStreamMethod(CodeInspector inspector) {
-    assertTrue(inspector.clazz(CustomArrayList.class).uniqueMethodWithName("stream").isAbsent());
-    assertTrue(inspector.clazz(CustomSortedSet.class).uniqueMethodWithName("stream").isAbsent());
+    assertTrue(
+        inspector.clazz(CustomArrayList.class).uniqueMethodWithOriginalName("stream").isAbsent());
+    assertTrue(
+        inspector.clazz(CustomSortedSet.class).uniqueMethodWithOriginalName("stream").isAbsent());
   }
 
   static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
index c799716..a695eba 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
@@ -61,8 +61,10 @@
   }
 
   private void assertNoForwardingStreamMethod(CodeInspector inspector) {
-    assertTrue(inspector.clazz(CustomArrayList.class).uniqueMethodWithName("stream").isAbsent());
-    assertTrue(inspector.clazz(CustomSortedSet.class).uniqueMethodWithName("stream").isAbsent());
+    assertTrue(
+        inspector.clazz(CustomArrayList.class).uniqueMethodWithOriginalName("stream").isAbsent());
+    assertTrue(
+        inspector.clazz(CustomSortedSet.class).uniqueMethodWithOriginalName("stream").isAbsent());
   }
 
   static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
index 2306edf..bd8d7c5 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
@@ -202,95 +202,95 @@
             : "java.util.function.Supplier";
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsCompare"),
+        testClass.uniqueMethodWithOriginalName("objectsCompare"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsCompare("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsCompare"),
+        testClass.uniqueMethodWithOriginalName("objectsCompare"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsCompare("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsDeepEquals"),
+        testClass.uniqueMethodWithOriginalName("objectsDeepEquals"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsDeepEquals("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsDeepEquals"),
+        testClass.uniqueMethodWithOriginalName("objectsDeepEquals"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsDeepEquals("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsEquals"),
+        testClass.uniqueMethodWithOriginalName("objectsEquals"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsEquals("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsEquals"),
+        testClass.uniqueMethodWithOriginalName("objectsEquals"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsEquals("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsHash"),
+        testClass.uniqueMethodWithOriginalName("objectsHash"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsHash("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsHash"),
+        testClass.uniqueMethodWithOriginalName("objectsHash"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsHash("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsHashCode"),
+        testClass.uniqueMethodWithOriginalName("objectsHashCode"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsHashCode("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsHashCode"),
+        testClass.uniqueMethodWithOriginalName("objectsHashCode"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsHashCode("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNull"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNull"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsRequireNonNull("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNull"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNull"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsRequireNonNull("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNullWithMessage"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithMessage"),
         onlyIf(
             invokeJavaUtilObjects, invokesObjectsRequireNonNullWithMessage("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNullWithMessage"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithMessage"),
         onlyIf(
             invokeJDollarUtilObjects, invokesObjectsRequireNonNullWithMessage("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNullWithSupplier"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithSupplier"),
         onlyIf(
             invokeJavaUtilObjectsWithSupplier,
             invokesObjectsRequireNonNullWithSupplier("java.util.Objects", supplier)));
     assertThat(
-        testClass.uniqueMethodWithName("objectsRequireNonNullWithSupplier"),
+        testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithSupplier"),
         onlyIf(
             invokeJDollarUtilObjectsWithSupplier,
             invokesObjectsRequireNonNullWithSupplier("j$.util.Objects", supplier)));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsToString"),
+        testClass.uniqueMethodWithOriginalName("objectsToString"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsToString("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsToString"),
+        testClass.uniqueMethodWithOriginalName("objectsToString"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsToString("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsToStringWithNullDefault"),
+        testClass.uniqueMethodWithOriginalName("objectsToStringWithNullDefault"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsToStringWithNullDefault("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsToStringWithNullDefault"),
+        testClass.uniqueMethodWithOriginalName("objectsToStringWithNullDefault"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsToStringWithNullDefault("j$.util.Objects")));
 
     invokeJavaUtilObjects = parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsIsNull"),
+        testClass.uniqueMethodWithOriginalName("objectsIsNull"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsIsNull("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsIsNull"),
+        testClass.uniqueMethodWithOriginalName("objectsIsNull"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsIsNull("j$.util.Objects")));
 
     assertThat(
-        testClass.uniqueMethodWithName("objectsNonNull"),
+        testClass.uniqueMethodWithOriginalName("objectsNonNull"),
         onlyIf(invokeJavaUtilObjects, invokesObjectsNonNull("java.util.Objects")));
     assertThat(
-        testClass.uniqueMethodWithName("objectsNonNull"),
+        testClass.uniqueMethodWithOriginalName("objectsNonNull"),
         onlyIf(invokeJDollarUtilObjects, invokesObjectsNonNull("j$.util.Objects")));
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
index 51222b2..535da2a 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
@@ -144,7 +144,7 @@
     assertThat(classSubject, isPresent());
     List<InstructionSubject> invokes =
         classSubject
-            .uniqueMethodWithName("main")
+            .uniqueMethodWithOriginalName("main")
             .streamInstructions()
             .filter(instr -> instr.isInvokeInterface() || instr.isInvokeStatic())
             .collect(Collectors.toList());
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
index 91721e2..bf335b8 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
@@ -79,7 +79,7 @@
               assertTrue(
                   inspector
                       .clazz("j$.time.Duration")
-                      .uniqueMethodWithName("toMillis")
+                      .uniqueMethodWithOriginalName("toMillis")
                       .streamInstructions()
                       .filter(InstructionSubject::isInvokeStatic)
                       .map(InstructionSubject::toString)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
index 1009f56..91669ae 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
@@ -84,7 +84,7 @@
     ClassSubject mapClass = inspector.clazz("j$.util.concurrent.ConcurrentHashMap");
     if (parameters.getApiLevel().isLessThan(AndroidApiLevel.N)) {
       assertTrue(mapClass.isPresent());
-      FieldSubject serialVersionUID = mapClass.uniqueFieldWithName("serialVersionUID");
+      FieldSubject serialVersionUID = mapClass.uniqueFieldWithOriginalName("serialVersionUID");
       assertTrue(serialVersionUID.isPresent());
     } else {
       assertFalse(mapClass.isPresent());
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
index 54b3bc9..2e2e8fb 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
@@ -5,16 +5,17 @@
 package com.android.tools.r8.desugar.desugaredlibrary.jdk11;
 
 import static com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification.DEFAULT_SPECIFICATIONS;
-import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.getJdk8Jdk11;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_PATH;
 
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification;
 import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
@@ -31,18 +32,15 @@
   private final CompilationSpecification compilationSpecification;
 
   private static final Path INPUT_JAR =
-      Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR + "timeunit.jar");
-  private static final String EXPECTED_OUTPUT = StringUtils.lines("Nanos");
+      Paths.get(ToolHelper.EXAMPLES_JAVA11_JAR_DIR + "timeunit.jar");
+  private static final String EXPECTED_OUTPUT = StringUtils.lines("Nanos", "0");
   private static final String MAIN_CLASS = "timeunit.Example";
 
   @Parameters(name = "{0}, spec: {1}, {2}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters()
-            .withDexRuntimesStartingFromIncluding(Version.V13_0_0)
-            .withApiLevel(AndroidApiLevel.B)
-            .build(),
-        getJdk8Jdk11(),
+        getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+        ImmutableList.of(JDK11, JDK11_PATH),
         DEFAULT_SPECIFICATIONS);
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
index b67d511..6ef6b8b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
@@ -38,6 +38,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import org.junit.Assume;
@@ -344,14 +345,16 @@
     builder.addLibraryFiles(libraryDesugaringSpecification.getLibraryFiles());
   }
 
-  public DesugaredLibraryTestCompileResult<T> compile() throws Exception {
+  public DesugaredLibraryTestCompileResult<T> compile()
+      throws CompilationFailedException, IOException, ExecutionException {
     prepareCompilation();
     TestCompileResult<?, ? extends SingleTestRunResult<?>> compile = builder.compile();
     return internalCompile(compile);
   }
 
   public DesugaredLibraryTestCompileResult<T> compileWithExpectedDiagnostics(
-      DiagnosticsConsumer consumer) throws Exception {
+      DiagnosticsConsumer consumer)
+      throws CompilationFailedException, IOException, ExecutionException {
     prepareCompilation();
     TestCompileResult<?, ? extends SingleTestRunResult<?>> compile =
         builder.compileWithExpectedDiagnostics(consumer);
@@ -359,7 +362,8 @@
   }
 
   private DesugaredLibraryTestCompileResult<T> internalCompile(
-      TestCompileResult<?, ? extends SingleTestRunResult<?>> compile) throws Exception {
+      TestCompileResult<?, ? extends SingleTestRunResult<?>> compile)
+      throws CompilationFailedException, IOException, ExecutionException {
     L8TestCompileResult l8Compile = compileDesugaredLibrary(compile, keepRuleConsumer);
     D8TestCompileResult customLibCompile = compileCustomLib();
     return new DesugaredLibraryTestCompileResult<>(
@@ -382,7 +386,7 @@
   private L8TestCompileResult compileDesugaredLibrary(
       TestCompileResult<?, ? extends SingleTestRunResult<?>> compile,
       KeepRuleConsumer keepRuleConsumer)
-      throws Exception {
+      throws CompilationFailedException, IOException, ExecutionException {
     if (!compilationSpecification.isL8Shrink()) {
       return compileDesugaredLibrary(null);
     }
@@ -401,7 +405,8 @@
     return compileDesugaredLibrary(keepRules);
   }
 
-  private L8TestCompileResult compileDesugaredLibrary(String keepRule) throws Exception {
+  private L8TestCompileResult compileDesugaredLibrary(String keepRule)
+      throws CompilationFailedException, IOException, ExecutionException {
     assert !compilationSpecification.isL8Shrink() || keepRule != null;
     return test.testForL8(parameters.getApiLevel(), parameters.getBackend())
         .apply(
@@ -427,7 +432,8 @@
   }
 
   public String collectKeepRulesWithTraceReferences(
-      Path desugaredProgramClassFile, Path desugaredLibraryClassFile) throws Exception {
+      Path desugaredProgramClassFile, Path desugaredLibraryClassFile)
+      throws CompilationFailedException, IOException {
     Path generatedKeepRules = test.temp.newFile().toPath();
     ArrayList<String> args = new ArrayList<>();
     args.add("--keep-rules");
@@ -449,12 +455,12 @@
   }
 
   public SingleTestRunResult<?> run(TestRuntime runtime, Class<?> mainClass, String... args)
-      throws Exception {
+      throws ExecutionException, IOException, CompilationFailedException {
     return compile().run(runtime, mainClass.getTypeName(), args);
   }
 
   public SingleTestRunResult<?> run(TestRuntime runtime, String mainClass, String... args)
-      throws Exception {
+      throws ExecutionException, IOException, CompilationFailedException {
     return compile().run(runtime, mainClass, args);
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
index bd11465..3172876 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
@@ -18,6 +18,7 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
 public class DesugaredLibraryTestCompileResult<T extends DesugaredLibraryTestBase> {
@@ -41,7 +42,7 @@
       CompilationSpecification compilationSpecification,
       D8TestCompileResult customLibCompile,
       L8TestCompileResult l8Compile)
-      throws Exception {
+      throws CompilationFailedException, IOException {
     this.test = test;
     this.compileResult = compileResult;
     this.parameters = parameters;
@@ -53,26 +54,26 @@
   }
 
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectCustomLib(
-      ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+      ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
     assert customLibCompile != null;
     customLibCompile.inspect(consumer);
     return this;
   }
 
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectL8(
-      ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+      ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
     l8Compile.inspect(consumer);
     return this;
   }
 
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspect(
-      ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+      ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
     compileResult.inspect(consumer);
     return this;
   }
 
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectKeepRules(
-      ThrowingConsumer<List<String>, E> consumer) throws Throwable {
+      ThrowingConsumer<List<String>, E> consumer) throws E {
     if (compilationSpecification.isL8Shrink()) {
       l8Compile.inspectKeepRules(consumer);
     }
@@ -80,21 +81,21 @@
   }
 
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> apply(
-      ThrowingConsumer<DesugaredLibraryTestCompileResult<T>, E> consumer) throws Throwable {
+      ThrowingConsumer<DesugaredLibraryTestCompileResult<T>, E> consumer) throws E {
     consumer.accept(this);
     return this;
   }
 
-  public CodeInspector customLibInspector() throws Throwable {
+  public CodeInspector customLibInspector() throws IOException {
     assert customLibCompile != null;
     return customLibCompile.inspector();
   }
 
-  public CodeInspector l8Inspector() throws Throwable {
+  public CodeInspector l8Inspector() throws IOException {
     return l8Compile.inspector();
   }
 
-  public CodeInspector inspector() throws Throwable {
+  public CodeInspector inspector() throws IOException {
     return compileResult.inspector();
   }
 
@@ -105,17 +106,17 @@
   }
 
   public SingleTestRunResult<?> run(TestRuntime runtime, Class<?> mainClass, String... args)
-      throws Exception {
+      throws ExecutionException, IOException {
     return run(runtime, mainClass.getTypeName(), args);
   }
 
   public SingleTestRunResult<?> run(TestRuntime runtime, String mainClassName, String... args)
-      throws Exception {
+      throws ExecutionException, IOException {
     return runnableCompiledResult.run(runtime, mainClassName, args);
   }
 
   private TestCompileResult<?, ? extends SingleTestRunResult<?>> computeRunnableCompiledResult()
-      throws Exception {
+      throws CompilationFailedException, IOException {
     TestCompileResult<?, ? extends SingleTestRunResult<?>> runnable = convertToDexIfNeeded();
     if (customLibCompile != null) {
       runnable.addRunClasspathFiles(customLibCompile.writeToZip());
diff --git a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
index 5e4e61a..7ee4955 100644
--- a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
+++ b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
@@ -44,13 +44,13 @@
     assertTrue(
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("f")
+            .uniqueMethodWithOriginalName("f")
             .streamInstructions()
             .noneMatch(InstructionSubject::isInvokeVirtual));
     assertTrue(
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("g")
+            .uniqueMethodWithOriginalName("g")
             .streamInstructions()
             .noneMatch(InstructionSubject::isInvokeVirtual));
   }
@@ -62,7 +62,7 @@
         1,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("f")
+            .uniqueMethodWithOriginalName("f")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeInterface)
             .count());
@@ -70,7 +70,7 @@
         2,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("f")
+            .uniqueMethodWithOriginalName("f")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeVirtual)
             .count());
@@ -78,7 +78,7 @@
         2,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("g")
+            .uniqueMethodWithOriginalName("g")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeInterface)
             .count());
@@ -86,7 +86,7 @@
         2,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("g")
+            .uniqueMethodWithOriginalName("g")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeInterface)
             .count());
@@ -94,7 +94,7 @@
         invokeVirtualCount,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("g")
+            .uniqueMethodWithOriginalName("g")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeVirtual)
             .count());
@@ -102,7 +102,7 @@
         getClassCount,
         inspector
             .clazz(Jdk8272564.Main.typeName())
-            .uniqueMethodWithName("g")
+            .uniqueMethodWithOriginalName("g")
             .streamInstructions()
             .filter(InstructionSubject::isInvoke)
             .filter(instruction -> instruction.getMethod().getName().toString().equals("getClass"))
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
index 61b75de..5802f93 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
@@ -50,16 +50,20 @@
         new CodeInspector(ToolHelper.getClassFileForTestClass(LambdaTest.class));
     inspector.forAllClasses(clazz -> clazz.forAllMethods(System.out::println));
     assertThat(
-        inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_PUBLIC), isPrivate());
+        inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_PUBLIC),
+        isPrivate());
     assertThat(
-        inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_NATIVE), isPrivate());
+        inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_NATIVE),
+        isPrivate());
   }
 
   private void inspect(CodeInspector inspector) {
     assertThat(
-        inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_PUBLIC), isPublic());
+        inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_PUBLIC),
+        isPublic());
     assertThat(
-        inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_NATIVE), isNative());
+        inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_NATIVE),
+        isNative());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
index b3d4ca5..34fec39 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
@@ -94,15 +94,15 @@
               assertEquals(
                   2,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("h1")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
             })
         .run(parameters.getRuntime(), "HostImpl")
         .assertFailureWithErrorThatThrows(IllegalAccessError.class);
@@ -126,7 +126,7 @@
                   assertEquals(
                       2,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host").uniqueMethodWithName("h1")));
+                          inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
                 })
             .writeToZip();
 
@@ -142,7 +142,7 @@
                   assertEquals(
                       1,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                          inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
                 })
             .writeToZip();
 
@@ -158,7 +158,7 @@
                   assertEquals(
                       1,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                          inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
                 })
             .writeToZip();
 
@@ -182,15 +182,15 @@
               assertEquals(
                   2,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("h1")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
             })
         .run(parameters.getRuntime(), "HostImpl")
         .assertFailureWithErrorThatThrows(IllegalAccessError.class);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
index 4d47a29..715989f 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
@@ -80,19 +80,19 @@
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("main")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
               assertEquals(
                   2,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("h1")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
             })
         .run(parameters.getRuntime(), "Host")
         .assertFailureWithErrorThatThrows(IllegalAccessError.class);
@@ -116,11 +116,11 @@
                   assertEquals(
                       1,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host").uniqueMethodWithName("main")));
+                          inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
                   assertEquals(
                       2,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host").uniqueMethodWithName("h1")));
+                          inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
                 })
             .writeToZip();
 
@@ -136,7 +136,7 @@
                   assertEquals(
                       1,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                          inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
                 })
             .writeToZip();
 
@@ -152,7 +152,7 @@
                   assertEquals(
                       1,
                       nonConstructorInvokeDirectCount(
-                          inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                          inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
                 })
             .writeToZip();
 
@@ -167,19 +167,19 @@
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("main")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
               assertEquals(
                   2,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host").uniqueMethodWithName("h1")));
+                      inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
               assertEquals(
                   1,
                   nonConstructorInvokeDirectCount(
-                      inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+                      inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
             })
         .run(parameters.getRuntime(), "Host")
         .assertFailureWithErrorThatThrows(IllegalAccessError.class);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
index a235beb..155d082 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
@@ -84,13 +84,13 @@
                       method.toString().contains("nestPvtCallToInline")
                           || method.toString().contains("methodWithPvtCallToInline")));
       // Inlining nest access should transform virtual/ift invokes -> direct.
-      MethodSubject methodSubject = subj.uniqueMethodWithName("dispatchInlining");
+      MethodSubject methodSubject = subj.uniqueMethodWithOriginalName("dispatchInlining");
       if (methodSubject.isPresent()) {
         nbDispatchInlining++;
         assertTrue(
             methodSubject.streamInstructions().noneMatch(InstructionSubject::isInvokeVirtual));
       }
-      methodSubject = subj.uniqueMethodWithName("notInlinedPvtCall");
+      methodSubject = subj.uniqueMethodWithOriginalName("notInlinedPvtCall");
       if (methodSubject.isPresent()) {
         nbNotInlinedPvtCall++;
       }
diff --git a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
index e1d397a..e4386e4 100644
--- a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
@@ -60,14 +60,14 @@
             DesugarTestConfiguration::isDesugared,
             inspector ->
                 hasInvokesTo(
-                    inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+                    inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
                     "getSuppressed",
                     apiLevelHasSuppressedExceptionsSupport() ? 1 : 0))
         .inspectIf(
             DesugarTestConfiguration::isNotDesugared,
             inspector ->
                 hasInvokesTo(
-                    inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+                    inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
                     "getSuppressed",
                     1));
   }
@@ -87,7 +87,7 @@
         .inspect(
             inspector -> {
               hasInvokesTo(
-                  inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+                  inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
                   "getSuppressed",
                   apiLevelHasSuppressedExceptionsSupport() ? 1 : 0);
               IntBox gets = new IntBox(0);
diff --git a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
index 62d5240..8ff8ca2 100644
--- a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
@@ -84,7 +84,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(MAIN.typeName());
               hasInvokesTo(
-                  clazz.uniqueMethodWithName("bar"),
+                  clazz.uniqueMethodWithOriginalName("bar"),
                   "$closeResource",
                   apiLevelHasTwrCloseResourceSupport() ? 4 : 0);
               if (apiLevelHasSuppressedExceptionsSupport()) {
@@ -103,7 +103,7 @@
             DesugarTestConfiguration::isNotDesugared,
             inspector -> {
               ClassSubject clazz = inspector.clazz(MAIN.typeName());
-              hasInvokesTo(clazz.uniqueMethodWithName("bar"), "$closeResource", 4);
+              hasInvokesTo(clazz.uniqueMethodWithOriginalName("bar"), "$closeResource", 4);
               hasInvokesTo(clazz.mainMethod(), "getSuppressed", 1);
             });
   }
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
index 46bfd05..a753b6c 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
@@ -38,7 +38,7 @@
     assertTrue(
         inspector
             .clazz(B.class)
-            .uniqueMethodWithName("compose")
+            .uniqueMethodWithOriginalName("compose")
             .streamInstructions()
             .filter(InstructionSubject::isInvoke)
             .map(invoke -> invoke.getMethod().getHolderType().toString())
diff --git a/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java b/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
index 90cf068..e09c293 100644
--- a/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
+++ b/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
@@ -51,6 +51,7 @@
                 GlobalSyntheticsStrategy.forNonSynthesizing()));
     return new ObjectToOffsetMapping(
         appView,
+        null,
         new LensCodeRewriterUtils(appView),
         Collections.emptyList(),
         Collections.emptyList(),
diff --git a/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java b/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java
new file mode 100644
index 0000000..af1ee96
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java
@@ -0,0 +1,182 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.dex.container;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.maindexlist.MainDexListTests;
+import com.android.tools.r8.transformers.ClassTransformer;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class DexContainerFormatBasicTest extends TestBase {
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  private static Path inputA;
+  private static Path inputB;
+
+  @BeforeClass
+  public static void generateTestApplications() throws Throwable {
+    // Build two applications in different packages both with required multidex due to number
+    // of methods.
+    inputA = getStaticTemp().getRoot().toPath().resolve("application_a.jar");
+    inputB = getStaticTemp().getRoot().toPath().resolve("application_b.jar");
+
+    generateApplication(inputA, "a", 10);
+    generateApplication(inputB, "b", 10);
+  }
+
+  @Test
+  public void testNonContainerD8() throws Exception {
+    Path outputA =
+        testForD8(Backend.DEX)
+            .addProgramFiles(inputA)
+            .setMinApi(AndroidApiLevel.L)
+            .compile()
+            .writeToZip();
+    assertEquals(2, unzipContent(outputA).size());
+
+    Path outputB =
+        testForD8(Backend.DEX)
+            .addProgramFiles(inputB)
+            .setMinApi(AndroidApiLevel.L)
+            .compile()
+            .writeToZip();
+    assertEquals(2, unzipContent(outputB).size());
+
+    Path outputMerged =
+        testForD8(Backend.DEX)
+            .addProgramFiles(outputA, outputB)
+            .setMinApi(AndroidApiLevel.L)
+            .compile()
+            .writeToZip();
+    assertEquals(4, unzipContent(outputMerged).size());
+  }
+
+  @Test
+  public void testD8Experiment() throws Exception {
+    Path outputFromDexing =
+        testForD8(Backend.DEX)
+            .addProgramFiles(inputA)
+            .setMinApi(AndroidApiLevel.L)
+            .addOptionsModification(
+                options -> options.getTestingOptions().dexContainerExperiment = true)
+            .compile()
+            .writeToZip();
+    List<byte[]> dexFromDexing = unzipContent(outputFromDexing);
+    assertEquals(1, dexFromDexing.size());
+  }
+
+  @Test
+  public void testD8Experiment2() throws Exception {
+    Path outputA =
+        testForD8(Backend.DEX)
+            .addProgramFiles(inputA)
+            .setMinApi(AndroidApiLevel.L)
+            .addOptionsModification(
+                options -> options.getTestingOptions().dexContainerExperiment = true)
+            .compile()
+            .writeToZip();
+    assertEquals(1, unzipContent(outputA).size());
+
+    Path outputB =
+        testForD8(Backend.DEX)
+            .addProgramFiles(inputB)
+            .setMinApi(AndroidApiLevel.L)
+            .addOptionsModification(
+                options -> options.getTestingOptions().dexContainerExperiment = true)
+            .compile()
+            .writeToZip();
+    assertEquals(1, unzipContent(outputB).size());
+  }
+
+  private List<byte[]> unzipContent(Path zip) throws IOException {
+    List<byte[]> result = new ArrayList<>();
+    ZipUtils.iter(zip, (entry, inputStream) -> result.add(ByteStreams.toByteArray(inputStream)));
+    return result;
+  }
+
+  private static void generateApplication(Path applicationJar, String rootPackage, int methodCount)
+      throws Throwable {
+    ImmutableList.Builder<String> builder = ImmutableList.builder();
+    for (int i = 0; i < 10000; ++i) {
+      String pkg = rootPackage + "." + (i % 2 == 0 ? "a" : "b");
+      String className = "Class" + i;
+      builder.add(pkg + "." + className);
+    }
+    List<String> classes = builder.build();
+
+    generateApplication(applicationJar, classes, methodCount);
+  }
+
+  private static void generateApplication(Path output, List<String> classes, int methodCount)
+      throws IOException {
+    ArchiveConsumer consumer = new ArchiveConsumer(output);
+    for (String typename : classes) {
+      String descriptor = DescriptorUtils.javaTypeToDescriptor(typename);
+      byte[] bytes =
+          transformer(MainDexListTests.ClassStub.class)
+              .setClassDescriptor(descriptor)
+              .addClassTransformer(
+                  new ClassTransformer() {
+                    @Override
+                    public MethodVisitor visitMethod(
+                        int access,
+                        String name,
+                        String descriptor,
+                        String signature,
+                        String[] exceptions) {
+                      // This strips <init>() too.
+                      if (name.equals("methodStub")) {
+                        for (int i = 0; i < methodCount; i++) {
+                          MethodVisitor mv =
+                              super.visitMethod(
+                                  access, "method" + i, descriptor, signature, exceptions);
+                          mv.visitCode();
+                          mv.visitInsn(Opcodes.RETURN);
+                          mv.visitMaxs(0, 0);
+                          mv.visitEnd();
+                        }
+                      }
+                      return null;
+                    }
+                  })
+              .transform();
+      consumer.accept(ByteDataView.of(bytes), descriptor, null);
+    }
+    consumer.finished(null);
+  }
+
+  // Simple stub/template for generating the input classes.
+  public static class ClassStub {
+    public static void methodStub() {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
index f56464c..bf5614e 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
@@ -55,7 +55,8 @@
                       ClassSubject baseSuperClassSubject = inspector.clazz(BaseSuperClass.class);
                       assertThat(baseSuperClassSubject, isPresent());
 
-                      FieldSubject fieldSubject = baseSuperClassSubject.uniqueFieldWithName("f");
+                      FieldSubject fieldSubject =
+                          baseSuperClassSubject.uniqueFieldWithOriginalName("f");
                       assertThat(fieldSubject, isPresent());
                       assertEquals(
                           Object.class.getTypeName(),
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
index a7fef57..af67cbb 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
@@ -60,7 +60,7 @@
         r8TestCompileResult -> {
           // Ensure that isEarly from BaseUtilClass is inlined into the feature
           ClassSubject clazz = r8TestCompileResult.inspector().clazz(BaseUtilClass.class);
-          assertThat(clazz.uniqueMethodWithName("isEarly"), not(isPresent()));
+          assertThat(clazz.uniqueMethodWithOriginalName("isEarly"), not(isPresent()));
         };
     ProcessResult processResult =
         testR8Splitter(
diff --git a/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java b/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
index 52aafa3..cceb957 100644
--- a/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
+++ b/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -37,7 +36,7 @@
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withCfRuntime(CfVm.JDK9).build();
+    return getTestParameters().withSystemRuntime().build();
   }
 
   public DumpInputsTest(TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java
new file mode 100644
index 0000000..24743b6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** This is a regression for b/247146910. */
+@RunWith(Parameterized.class)
+public class EnumImplementingInterfaceAssignmentOutsideTest extends EnumUnboxingTestBase {
+
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  private final String[] EXPECTED = new String[] {"Bar", "Hello World!"};
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public EnumImplementingInterfaceAssignmentOutsideTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addInnerClasses(EnumImplementingInterfaceAssignmentOutsideTest.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    // TODO(b/247146910): We should not fail compilation. If running without assertions this
+    //  inserts throw null for the code.
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForR8(parameters.getBackend())
+                .addInnerClasses(EnumImplementingInterfaceAssignmentOutsideTest.class)
+                .addKeepMainRule(Main.class)
+                .addKeepRules(enumKeepRules.getKeepRules())
+                .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+                .compile());
+  }
+
+  public interface I {
+
+    String get();
+  }
+
+  @NeverClassInline
+  public enum OtherEnum implements I {
+    C("Foo"),
+    D("Bar");
+
+    private final String value;
+
+    OtherEnum(String value) {
+      this.value = value;
+    }
+
+    @Override
+    public String get() {
+      return value;
+    }
+  }
+
+  @NeverClassInline
+  public enum MyEnum {
+    A(),
+    B();
+
+    public I otherEnum;
+  }
+
+  public static class Main implements I {
+
+    public static void main(String[] args) throws Exception {
+      setInterfaceValue(System.currentTimeMillis() == 0 ? OtherEnum.C : OtherEnum.D);
+      System.out.println(MyEnum.A.otherEnum.get());
+      System.out.println(new Main().get());
+    }
+
+    private static void setInterfaceValue(I i) {
+      if (System.currentTimeMillis() > 0) {
+        MyEnum.A.otherEnum = i;
+      } else {
+        MyEnum.B.otherEnum = i;
+      }
+    }
+
+    @Override
+    public String get() {
+      if (System.currentTimeMillis() == 0) {
+        throw new RuntimeException("Foo");
+      }
+      return "Hello World!";
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java
new file mode 100644
index 0000000..be45f4c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java
@@ -0,0 +1,115 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** This is a regression for b/247146910. */
+@RunWith(Parameterized.class)
+public class EnumImplementingInterfaceTest extends EnumUnboxingTestBase {
+
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  private final String[] EXPECTED = new String[] {"Foo", "Hello World!"};
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public EnumImplementingInterfaceTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addInnerClasses(EnumImplementingInterfaceTest.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    // TODO(b/247146910): We should not fail compilation. If running without assertions this
+    //  inserts throw null for the code.
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForR8(parameters.getBackend())
+                .addInnerClasses(EnumImplementingInterfaceTest.class)
+                .addKeepMainRule(Main.class)
+                .addKeepRules(enumKeepRules.getKeepRules())
+                .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+                .compile());
+  }
+
+  public interface I {
+
+    String get();
+  }
+
+  @NeverClassInline
+  public enum OtherEnum implements I {
+    C("Foo"),
+    D("Bar");
+
+    private final String value;
+
+    OtherEnum(String value) {
+      this.value = value;
+    }
+
+    @Override
+    public String get() {
+      return value;
+    }
+  }
+
+  @NeverClassInline
+  public enum MyEnum {
+    A(OtherEnum.C),
+    B(OtherEnum.D);
+
+    public I otherEnum;
+
+    MyEnum(I otherEnum) {
+      this.otherEnum = otherEnum;
+      if (System.currentTimeMillis() == 0) {
+        this.otherEnum = null;
+      }
+    }
+  }
+
+  public static class Main implements I {
+
+    public static void main(String[] args) throws Exception {
+      System.out.println(MyEnum.A.otherEnum.get());
+      System.out.println(new Main().get());
+    }
+
+    @Override
+    public String get() {
+      if (System.currentTimeMillis() == 0) {
+        throw new RuntimeException("Foo");
+      }
+      return "Hello World!";
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
index 12dfd1f..b9b1e42 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
@@ -66,11 +66,12 @@
     if (parameters.isCfRuntime()) {
       // There is no class staticizer in Cf.
       assertThat(
-          codeInspector.clazz(Companion.class).uniqueMethodWithName(renamedMethodName),
+          codeInspector.clazz(Companion.class).uniqueMethodWithOriginalName(renamedMethodName),
           isPresent());
       return;
     }
-    MethodSubject method = codeInspector.clazz(Companion.class).uniqueMethodWithName("method");
+    MethodSubject method =
+        codeInspector.clazz(Companion.class).uniqueMethodWithOriginalName("method");
     assertThat(method, isPresent());
     assertEquals("int", method.getMethod().getParameters().toString());
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
index 19aa6fe..52e4a53 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
@@ -87,7 +87,8 @@
         inspector.clazz(InstanceFieldPutObject.class).getDexProgramClass().instanceFields().size());
     assertEquals(
         1, inspector.clazz(StaticFieldPutObject.class).getDexProgramClass().staticFields().size());
-    assertTrue(inspector.clazz(FailingPhi.class).uniqueMethodWithName("switchOn").isPresent());
+    assertTrue(
+        inspector.clazz(FailingPhi.class).uniqueMethodWithOriginalName("switchOn").isPresent());
   }
 
   static class InstanceFieldPutObject {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
index 670e3b3..8b67ed9 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
@@ -66,7 +66,7 @@
     }
     assertTrue(
         i.clazz(Switch.class)
-            .uniqueMethodWithName("switchOnEnumManyCases")
+            .uniqueMethodWithOriginalName("switchOnEnumManyCases")
             .streamInstructions()
             .anyMatch(InstructionSubject::isSwitch));
   }
diff --git a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
index 86176a0..16daaac 100644
--- a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
@@ -148,7 +148,7 @@
     // Testing FieldTypeSignature
     //
 
-    FieldSubject yyInZZ = zz.uniqueFieldWithName("yy");
+    FieldSubject yyInZZ = zz.uniqueFieldWithOriginalName("yy");
     assertThat(yyInZZ, isPresent());
     DexEncodedField field = yyInZZ.getField();
     assertNotNull(field);
@@ -165,7 +165,7 @@
     //
 
     // A$Y$YY newYY([B<T>)
-    MethodSubject newYY = zz.uniqueMethodWithName("newYY");
+    MethodSubject newYY = zz.uniqueMethodWithOriginalName("newYY");
     assertThat(newYY, isPresent());
     method = newYY.getMethod();
     assertNotNull(method);
@@ -207,7 +207,7 @@
     assertEquals(b.getDexProgramClass().type, classTypeSignature.type);
 
     // Function<A$Y$ZZ<TT>, A$Y$YY> convertToYY(Supplier<A$Y$ZZ<TT>>
-    MethodSubject convertToYY = zz.uniqueMethodWithName("convertToYY");
+    MethodSubject convertToYY = zz.uniqueMethodWithOriginalName("convertToYY");
     assertThat(convertToYY, isPresent());
     method = convertToYY.getMethod();
     assertNotNull(method);
@@ -243,7 +243,7 @@
     check_supplier(factory, a, y, zz, parameterSignature);
 
     // void boo(Supplier<A$Y$ZZ<TT>>)
-    MethodSubject boo = zz.uniqueMethodWithName("boo");
+    MethodSubject boo = zz.uniqueMethodWithOriginalName("boo");
     assertThat(boo, isPresent());
     method = boo.getMethod();
     assertNotNull(method);
@@ -295,11 +295,11 @@
   }
 
   private void check_A_Y_foo_bar_baz(ClassSubject y, AppView<AppInfoWithLiveness> appView) {
-    checkMethodWildCard(y.uniqueMethodWithName("foo"), appView, WildcardIndicator.POSITIVE);
-    checkMethodWildCard(y.uniqueMethodWithName("bar"), appView, WildcardIndicator.NEGATIVE);
+    checkMethodWildCard(y.uniqueMethodWithOriginalName("foo"), appView, WildcardIndicator.POSITIVE);
+    checkMethodWildCard(y.uniqueMethodWithOriginalName("bar"), appView, WildcardIndicator.NEGATIVE);
     // Check for star
     checkFieldTypeSignature(
-        y.uniqueMethodWithName("baz").asFoundMethodSubject(),
+        y.uniqueMethodWithOriginalName("baz").asFoundMethodSubject(),
         appView,
         typeSignature -> {
           assertTrue(typeSignature.isStar());
diff --git a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
index 333ab92..2d8035e 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.graph;
 
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
@@ -11,6 +12,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.UnverifiableCfCodeDiagnostic;
 import com.android.tools.r8.utils.codeinspector.AssertUtils;
 import java.io.IOException;
 import org.junit.Test;
@@ -76,7 +78,9 @@
                 .compileWithExpectedDiagnostics(
                     diagnostics ->
                         diagnostics
-                            .assertOnlyErrors()
+                            .assertNoInfos()
+                            // TODO(b/251482856): Is this an expected unverifiable code?
+                            .assertWarningsMatch(diagnosticType(UnverifiableCfCodeDiagnostic.class))
                             .inspectErrors(
                                 diagnostic ->
                                     diagnostic
diff --git a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
index 48877b9..efc246f 100644
--- a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
+++ b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
@@ -107,7 +107,7 @@
 
     ClassSubject innerClass = inspector.clazz(Inner.class);
     assertThat(innerClass, isPresent());
-    MethodSubject testMethod = innerClass.uniqueMethodWithName("test");
+    MethodSubject testMethod = innerClass.uniqueMethodWithOriginalName("test");
     assertThat(testMethod, isPresent());
     if (isCompat) {
       assertEquals("(TO;TM;)TI;", testMethod.getFinalSignatureAttribute());
diff --git a/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java b/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
index 8256c29..c77d3a3 100644
--- a/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
@@ -69,9 +69,9 @@
 
     // In any case, Outer.hello(), Outer.world(), and Outer.exclamationMark() should be inlined into
     // the accessibility bridges.
-    assertThat(outerClassSubject.uniqueMethodWithName("hello"), not(isPresent()));
-    assertThat(outerClassSubject.uniqueMethodWithName("world"), not(isPresent()));
-    assertThat(outerClassSubject.uniqueMethodWithName("exclamationMark"), not(isPresent()));
+    assertThat(outerClassSubject.uniqueMethodWithOriginalName("hello"), not(isPresent()));
+    assertThat(outerClassSubject.uniqueMethodWithOriginalName("world"), not(isPresent()));
+    assertThat(outerClassSubject.uniqueMethodWithOriginalName("exclamationMark"), not(isPresent()));
 
     int numberOfExpectedAccessibilityBridges = 0;
     assertEquals(
@@ -81,19 +81,19 @@
             .size());
     assertEquals(
         !enableInitializedClassesInInstanceMethodsAnalysis,
-        outerClassSubject.uniqueFieldWithName("$r8$clinit").isPresent());
+        outerClassSubject.uniqueFieldWithOriginalName("$r8$clinit").isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(Outer.A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("hello"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("hello"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(Outer.B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("world"), isPresent());
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("world"), isPresent());
 
     ClassSubject cClassSubject = inspector.clazz(C.class);
     assertThat(cClassSubject, isPresent());
-    assertThat(cClassSubject.uniqueMethodWithName("exclamationMark"), isPresent());
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("exclamationMark"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
index 262f164..de44d1c 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
@@ -191,7 +191,7 @@
     assertThat(generatedMessageLiteClassSubject, isPresent());
 
     MethodSubject isInitializedMethodSubject =
-        generatedMessageLiteClassSubject.uniqueMethodWithName("isInitialized");
+        generatedMessageLiteClassSubject.uniqueMethodWithOriginalName("isInitialized");
 
     DexType methodToInvokeType =
         outputInspector.clazz(METHOD_TO_INVOKE_ENUM).getDexProgramClass().getType();
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
index 51acd65..dbfb40f 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
@@ -23,7 +23,6 @@
 import com.google.common.collect.ImmutableSet;
 import java.nio.file.Path;
 import java.util.List;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -154,45 +153,57 @@
     {
       ClassSubject usedRootClassSubject = inputInspector.clazz(USED_ROOT);
       assertThat(usedRootClassSubject, isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldA_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldB_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("myOneof_"), isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("recursiveWithRequiredField_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("isExtendedWithOptional_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("isExtendedWithScalars_"), isPresent());
+          usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldA_"), isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isExtendedWithRequiredField_"), isPresent());
+          usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldB_"), isPresent());
+      assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("myOneof_"), isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isRepeatedlyExtendedWithRequiredField_"),
+          usedRootClassSubject.uniqueFieldWithOriginalName("recursiveWithRequiredField_"),
           isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasMapField_"), isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithOptional_"), isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithScalars_"), isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithRequiredField_"),
+          isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName(
+              "isRepeatedlyExtendedWithRequiredField_"),
+          isPresent());
+      assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("hasMapField_"), isPresent());
 
       ClassSubject hasRequiredFieldClassSubject = inputInspector.clazz(HAS_REQUIRED_FIELD);
       assertThat(hasRequiredFieldClassSubject, isPresent());
-      assertThat(hasRequiredFieldClassSubject.uniqueFieldWithName("value_"), isPresent());
+      assertThat(hasRequiredFieldClassSubject.uniqueFieldWithOriginalName("value_"), isPresent());
     }
 
     // Verify the existence of various fields in the output.
     {
       ClassSubject usedRootClassSubject = outputInspector.clazz(USED_ROOT);
       assertThat(usedRootClassSubject, isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldA_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldB_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("myOneof_"), isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("recursiveWithRequiredField_"), isPresent());
-      assertThat(usedRootClassSubject.uniqueFieldWithName("hasMapField_"), isPresent());
+          usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldA_"), isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldB_"), isPresent());
+      assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("myOneof_"), isPresent());
+      assertThat(
+          usedRootClassSubject.uniqueFieldWithOriginalName("recursiveWithRequiredField_"),
+          isPresent());
+      assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("hasMapField_"), isPresent());
 
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isExtendedWithRequiredField_"), isPresent());
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithRequiredField_"),
+          isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isRepeatedlyExtendedWithRequiredField_"),
+          usedRootClassSubject.uniqueFieldWithOriginalName(
+              "isRepeatedlyExtendedWithRequiredField_"),
           isPresent());
 
       ClassSubject hasRequiredFieldClassSubject = outputInspector.clazz(HAS_REQUIRED_FIELD);
       assertThat(hasRequiredFieldClassSubject, isPresent());
-      assertThat(hasRequiredFieldClassSubject.uniqueFieldWithName("value_"), isPresent());
+      assertThat(hasRequiredFieldClassSubject.uniqueFieldWithOriginalName("value_"), isPresent());
     }
 
     // Verify the absence of various fields in the output.
@@ -200,9 +211,11 @@
       ClassSubject usedRootClassSubject = outputInspector.clazz(USED_ROOT);
       assertThat(usedRootClassSubject, isPresent());
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isExtendedWithOptional_"), not(isPresent()));
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithOptional_"),
+          not(isPresent()));
       assertThat(
-          usedRootClassSubject.uniqueFieldWithName("isExtendedWithScalars_"), not(isPresent()));
+          usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithScalars_"),
+          not(isPresent()));
     }
   }
 
@@ -221,13 +234,16 @@
       ClassSubject generatedExtensionRegistryLoader = inputInspector.clazz(extensionRegistryName);
       assertThat(generatedExtensionRegistryLoader, isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber"),
           isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber1"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber1"),
           isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber2"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber2"),
           isPresent());
     }
 
@@ -240,13 +256,16 @@
       ClassSubject generatedExtensionRegistryLoader = outputInspector.clazz(extensionRegistryName);
       assertThat(generatedExtensionRegistryLoader, isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber"),
           isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber1"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber1"),
           isPresent());
       assertThat(
-          generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber2"),
+          generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+              "findLiteExtensionByNumber2"),
           notIf(isPresent(), enableMinification));
     }
 
@@ -268,45 +287,48 @@
     {
       ClassSubject cfofClassSubject = inputInspector.clazz(CONTAINS_FLAGGED_OFF_FIELD);
       assertThat(cfofClassSubject, isPresent());
-      assertThat(cfofClassSubject.uniqueFieldWithName("conditionallyUsed_"), isPresent());
+      assertThat(cfofClassSubject.uniqueFieldWithOriginalName("conditionallyUsed_"), isPresent());
 
       ClassSubject puClassSubject = inputInspector.clazz(PARTIALLY_USED);
       assertThat(puClassSubject, isPresent());
       assertEquals(7, puClassSubject.allInstanceFields().size());
-      assertThat(puClassSubject.uniqueFieldWithName("bitField0_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("unusedEnum_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedEnum_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("unusedMessage_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedMessage_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedEnum_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedEnum_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedMessage_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedMessage_"), isPresent());
 
       ClassSubject uvhClassSubject = inputInspector.clazz(USED_VIA_HAZZER);
       assertThat(uvhClassSubject, isPresent());
-      assertThat(uvhClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(uvhClassSubject.uniqueFieldWithName("unused_"), isPresent());
+      assertThat(uvhClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(uvhClassSubject.uniqueFieldWithOriginalName("unused_"), isPresent());
     }
 
     // Verify that various proto fields have been removed in the output.
     {
       ClassSubject cfofClassSubject = outputInspector.clazz(CONTAINS_FLAGGED_OFF_FIELD);
       assertThat(cfofClassSubject, isPresent());
-      assertThat(cfofClassSubject.uniqueFieldWithName("conditionallyUsed_"), not(isPresent()));
+      assertThat(
+          cfofClassSubject.uniqueFieldWithOriginalName("conditionallyUsed_"), not(isPresent()));
 
       ClassSubject puClassSubject = outputInspector.clazz(PARTIALLY_USED);
       assertThat(puClassSubject, isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("bitField0_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), not(isPresent()));
-      assertThat(puClassSubject.uniqueFieldWithName("unusedEnum_"), not(isPresent()));
-      assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedEnum_"), not(isPresent()));
-      assertThat(puClassSubject.uniqueFieldWithName("unusedMessage_"), not(isPresent()));
-      assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedMessage_"), not(isPresent()));
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), not(isPresent()));
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedEnum_"), not(isPresent()));
+      assertThat(
+          puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedEnum_"), not(isPresent()));
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedMessage_"), not(isPresent()));
+      assertThat(
+          puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedMessage_"), not(isPresent()));
 
       ClassSubject uvhClassSubject = outputInspector.clazz(USED_VIA_HAZZER);
       assertThat(uvhClassSubject, isPresent());
-      assertThat(uvhClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(uvhClassSubject.uniqueFieldWithName("unused_"), not(isPresent()));
+      assertThat(uvhClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(uvhClassSubject.uniqueFieldWithOriginalName("unused_"), not(isPresent()));
     }
   }
 
@@ -316,18 +338,18 @@
     {
       ClassSubject classSubject = inputInspector.clazz(USES_ONLY_REPEATED_FIELDS);
       assertThat(classSubject, isPresent());
-      assertThat(classSubject.uniqueFieldWithName("bitField0_"), isPresent());
-      assertThat(classSubject.uniqueFieldWithName("myoneof_"), isPresent());
-      assertThat(classSubject.uniqueFieldWithName("myoneofCase_"), isPresent());
+      assertThat(classSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+      assertThat(classSubject.uniqueFieldWithOriginalName("myoneof_"), isPresent());
+      assertThat(classSubject.uniqueFieldWithOriginalName("myoneofCase_"), isPresent());
     }
 
     // Verify that various proto fields have been removed in the output.
     {
       ClassSubject classSubject = outputInspector.clazz(USES_ONLY_REPEATED_FIELDS);
       assertThat(classSubject, isPresent());
-      assertThat(classSubject.uniqueFieldWithName("bitField0_"), not(isPresent()));
-      assertThat(classSubject.uniqueFieldWithName("myoneof_"), not(isPresent()));
-      assertThat(classSubject.uniqueFieldWithName("myoneofCase_"), not(isPresent()));
+      assertThat(classSubject.uniqueFieldWithOriginalName("bitField0_"), not(isPresent()));
+      assertThat(classSubject.uniqueFieldWithOriginalName("myoneof_"), not(isPresent()));
+      assertThat(classSubject.uniqueFieldWithOriginalName("myoneofCase_"), not(isPresent()));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
index e2b8e51..0fa0a5b 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
@@ -84,16 +84,16 @@
       ClassSubject puClassSubject = inputInspector.clazz(PARTIALLY_USED);
       assertThat(puClassSubject, isPresent());
       assertEquals(2, puClassSubject.allInstanceFields().size());
-      assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), isPresent());
     }
 
     // Verify that various proto fields have been removed in the output.
     {
       ClassSubject puClassSubject = outputInspector.clazz(PARTIALLY_USED);
       assertThat(puClassSubject, isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
-      assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), not(isPresent()));
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+      assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), not(isPresent()));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
index a015fd9..0f596b1 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
@@ -94,7 +94,8 @@
 
   public void buildAndCheckIR(String methodName, Consumer<IRCode> irInspector) {
     CodeInspector inspector = new CodeInspector(appView.appInfo().app());
-    MethodSubject methodSubject = inspector.clazz(className).uniqueMethodWithName(methodName);
+    MethodSubject methodSubject =
+        inspector.clazz(className).uniqueMethodWithOriginalName(methodName);
     irInspector.accept(methodSubject.buildIR(appView));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java b/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
index 7d05b2d..d48d5ad 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
@@ -68,7 +68,7 @@
       ClassSubject classSubject = inspector.clazz(A.class);
       assertThat(classSubject, isPresent());
 
-      MethodSubject methodSubject = classSubject.uniqueMethodWithName("inlineable");
+      MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("inlineable");
       assertThat(methodSubject, not(isPresent()));
     }
   }
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
index 065e069..c74f7e5 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
@@ -49,7 +49,7 @@
     assertThat(classSubject, isPresent());
 
     // We should have been able to inline A.inlineable() since A.<clinit>() can safely be postponed.
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
index a108b5f..2399475 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
@@ -55,10 +55,10 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     for (String methodName : ImmutableList.of("testIf", "testSwitch")) {
-      MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+      MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
       assertThat(methodSubject, isPresent());
 
       // Verify that all enum reads have been removed.
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
index eb3138c..ffce57c 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
@@ -69,7 +69,7 @@
                       "arrayWithIndirectFinalizer",
                       "otherArrayInstanceWithoutFinalizer");
               for (String name : presentFields) {
-                FieldSubject fieldSubject = classSubject.uniqueFieldWithName(name);
+                FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName(name);
                 assertThat(name, fieldSubject, isPresent());
                 assertTrue(
                     mainSubject
@@ -87,7 +87,7 @@
                       "indirectInstanceWithoutFinalizer",
                       "arrayWithoutFinalizer");
               for (String name : absentFields) {
-                assertThat(classSubject.uniqueFieldWithName(name), not(isPresent()));
+                assertThat(classSubject.uniqueFieldWithOriginalName(name), not(isPresent()));
               }
             })
         .run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
index 1950e53..31c7346 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
@@ -53,7 +53,7 @@
 
     // A.inlineable() should be inlined because we should be able to determine that A.<clinit>() can
     // safely be postponed.
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
index 7bc227a..61047fe 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
@@ -49,8 +49,8 @@
     assertThat(classSubject, isPresent());
 
     // The field A.INSTANCE has been accessed to allow inlining of A.inlineable().
-    assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
index 8d3cae4..abf1395 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
@@ -15,7 +15,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ir.analysis.sideeffect.SingletonClassInitializerPatternCanBePostponedTest.A;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import org.junit.Test;
@@ -55,10 +54,10 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
+    assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
 
     // A.inlineable() should be inlined, but we should not synthesize an $r8$clinit field.
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
     assertEquals(2, classSubject.allStaticFields().size());
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
index 5914a59..37f49fc 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
@@ -54,10 +54,10 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
+    assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
 
     // A.inlineable() should be inlined, but we should synthesize an $r8$clinit field.
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
     assertEquals(2, classSubject.allStaticFields().size());
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
index 6573810..7db7e04 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
@@ -71,7 +71,7 @@
                       "testWithSwitch",
                       "testNullCheckIsPreserved");
               for (String methodName : methodNames) {
-                MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+                MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
                 assertThat(methodSubject, isPresent());
                 IRCode code = methodSubject.buildIR();
                 List<Value> hashCodeValues =
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
index 9dcfa24..28c90bf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
@@ -190,7 +190,7 @@
 
     int expectedThrow = hasLiveness ? 1 : 0;
     for (String methodName : METHODS_WITH_NPE_GUARD) {
-      MethodSubject withNPEGuard = mainClass.uniqueMethodWithName(methodName);
+      MethodSubject withNPEGuard = mainClass.uniqueMethodWithOriginalName(methodName);
       assertThat(withNPEGuard, isPresent());
       // catch handlers could be split, and thus not always 1, but some small positive numbers.
       assertTrue(
@@ -205,12 +205,12 @@
 
     int expectedHandler = hasLiveness ? 0 : 1;
     MethodSubject withOtherGuard =
-        mainClass.uniqueMethodWithName("uninstantiatedInstancePutWithOtherGuard");
+        mainClass.uniqueMethodWithOriginalName("uninstantiatedInstancePutWithOtherGuard");
     assertThat(withOtherGuard, isPresent());
     assertEquals(expectedHandler, Streams.stream(withOtherGuard.iterateTryCatches()).count());
 
     for (String methodName : METHODS_WITHOUT_GUARD) {
-      MethodSubject mtd = mainClass.uniqueMethodWithName(methodName);
+      MethodSubject mtd = mainClass.uniqueMethodWithOriginalName(methodName);
       assertThat(mtd, isPresent());
       assertEquals(
           hasLiveness,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
index e582d84..c73086e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
@@ -89,24 +89,24 @@
     ClassSubject mainSubject = inspector.clazz(mainClass);
     assertThat(mainSubject, isPresent());
 
-    MethodSubject selfCheck = mainSubject.uniqueMethodWithName("selfCheck");
+    MethodSubject selfCheck = mainSubject.uniqueMethodWithOriginalName("selfCheck");
     assertThat(selfCheck, isPresent());
     assertEquals(0, countCallToParamNullCheck(selfCheck));
     assertEquals(1, countPrintCall(selfCheck));
     assertEquals(0, countThrow(selfCheck));
 
-    MethodSubject checkNull = mainSubject.uniqueMethodWithName("checkNull");
+    MethodSubject checkNull = mainSubject.uniqueMethodWithOriginalName("checkNull");
     assertThat(checkNull, isPresent());
     assertEquals(0, countCallToParamNullCheck(checkNull));
     assertEquals(1, countPrintCall(checkNull));
     assertEquals(1, countThrow(checkNull));
 
-    MethodSubject paramCheck = mainSubject.uniqueMethodWithName("nonNullAfterParamCheck");
+    MethodSubject paramCheck = mainSubject.uniqueMethodWithOriginalName("nonNullAfterParamCheck");
     assertThat(paramCheck, isPresent());
     assertEquals(1, countPrintCall(paramCheck));
     assertEquals(1, countThrow(paramCheck));
 
-    paramCheck = mainSubject.uniqueMethodWithName("nonNullAfterParamCheckDifferently");
+    paramCheck = mainSubject.uniqueMethodWithOriginalName("nonNullAfterParamCheckDifferently");
     assertThat(paramCheck, isPresent());
     assertEquals(1, countPrintCall(paramCheck));
     assertEquals(1, countThrow(paramCheck));
@@ -125,17 +125,18 @@
     ClassSubject mainSubject = inspector.clazz(mainClass);
     assertThat(mainSubject, isPresent());
 
-    MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+    MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
     assertThat(checkViaCall, isPresent());
     assertEquals(0, countActCall(checkViaCall));
     assertEquals(2, countPrintCall(checkViaCall));
 
-    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
     assertThat(checkViaIntrinsic, isPresent());
     assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
     assertEquals(1, countPrintCall(checkViaIntrinsic));
 
-    MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+    MethodSubject checkAtOneLevelHigher =
+        mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
     assertThat(checkAtOneLevelHigher, isPresent());
     assertEquals(1, countPrintCall(checkAtOneLevelHigher));
     assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -154,17 +155,18 @@
     ClassSubject mainSubject = inspector.clazz(mainClass);
     assertThat(mainSubject, isPresent());
 
-    MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+    MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
     assertThat(checkViaCall, isPresent());
     assertEquals(0, countActCall(checkViaCall));
     assertEquals(canSharePrintCallInSuccessorBlock() ? 1 : 2, countPrintCall(checkViaCall));
 
-    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
     assertThat(checkViaIntrinsic, isPresent());
     assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
     assertEquals(1, countPrintCall(checkViaIntrinsic));
 
-    MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+    MethodSubject checkAtOneLevelHigher =
+        mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
     assertThat(checkAtOneLevelHigher, isPresent());
     assertEquals(1, countPrintCall(checkAtOneLevelHigher));
     assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -190,17 +192,18 @@
     ClassSubject mainSubject = inspector.clazz(NonNullParamAfterInvokeVirtual.class);
     assertThat(mainSubject, isPresent());
 
-    MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+    MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
     assertThat(checkViaCall, isPresent());
     assertEquals(0, countActCall(checkViaCall));
     assertEquals(canSharePrintCallInSuccessorBlock() ? 1 : 2, countPrintCall(checkViaCall));
 
-    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+    MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
     assertThat(checkViaIntrinsic, isPresent());
     assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
     assertEquals(1, countPrintCall(checkViaIntrinsic));
 
-    MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+    MethodSubject checkAtOneLevelHigher =
+        mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
     assertThat(checkAtOneLevelHigher, isPresent());
     assertEquals(1, countPrintCall(checkAtOneLevelHigher));
     assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -246,7 +249,7 @@
     ClassSubject mainSubject = inspector.clazz(NonNullParamInterfaceImpl.class);
     assertThat(mainSubject, isPresent());
 
-    MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+    MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
     assertThat(checkViaCall, isPresent());
     assertEquals(0, countActCall(checkViaCall));
     // The DEX backend reuses the System.out.println invoke.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
index f40816f..843ceef 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
@@ -89,12 +89,12 @@
     assertThat(mainMethod, isPresent());
     assertEquals(expectedCountInMain, countObjectsRequireNonNull(mainMethod));
 
-    MethodSubject unknownArg = mainClass.uniqueMethodWithName("unknownArg");
+    MethodSubject unknownArg = mainClass.uniqueMethodWithOriginalName("unknownArg");
     assertThat(unknownArg, isPresent());
     // Due to the nullable argument, requireNonNull should remain.
     assertEquals(1, countObjectsRequireNonNull(unknownArg));
 
-    MethodSubject uninit = mainClass.uniqueMethodWithName("consumeUninitialized");
+    MethodSubject uninit = mainClass.uniqueMethodWithOriginalName("consumeUninitialized");
     assertThat(uninit, isPresent());
     assertEquals(expectedCountInConsumer, countObjectsRequireNonNull(uninit));
     if (expectedCountInConsumer == 0) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
index 7dc327c..ae4ea81 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
@@ -63,7 +63,8 @@
     // Main method invokes noNormalExits() since it is not allowed to be inlined.
     assertThat(
         mainMethodSubject,
-        invokesMethod(inspector.clazz(KeptClass.class).uniqueMethodWithName("noNormalExits")));
+        invokesMethod(
+            inspector.clazz(KeptClass.class).uniqueMethodWithOriginalName("noNormalExits")));
 
     // The fact that noNormalExits() never returns normally has only been exploited if it is not
     // kept.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index 303bf0c..0e02656 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -360,10 +360,10 @@
     CodeInspector inspector =
         new CodeInspector(ImmutableList.of(getGeneratedFile()), getGeneratedProguardMap(), null);
     ClassSubject clazz = inspector.clazz(nullabilityClass);
-    assertThat(clazz.uniqueMethodWithName("conditionalOperator"), isAbsent());
+    assertThat(clazz.uniqueMethodWithOriginalName("conditionalOperator"), isAbsent());
 
     // The enum parameter is unboxed.
-    MethodSubject m = clazz.uniqueMethodWithName("moreControlFlows");
+    MethodSubject m = clazz.uniqueMethodWithOriginalName("moreControlFlows");
     assertTrue(m.isPresent());
 
     // Verify that a.b() is resolved to an inline instance-get.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
index 27f097b..54fee4e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
@@ -71,15 +71,15 @@
             .assertSuccessWithOutput(expectedOutput);
 
     ClassSubject classSubject = result.inspector().clazz(TestClass.class);
-    verifyBooleanCheckTest(classSubject.uniqueMethodWithName("booleanCheckTest"));
-    verifyBooleanCheckTest(classSubject.uniqueMethodWithName("negateBooleanCheckTest"));
-    verifyIntCheckTest(classSubject.uniqueMethodWithName("intCheckTest"));
-    verifyIntCheckTest(classSubject.uniqueMethodWithName("negateIntCheckTest"));
-    verifyNullCheckTest(classSubject.uniqueMethodWithName("nullCheckTest"));
-    verifyNullCheckTest(classSubject.uniqueMethodWithName("invertedNullCheckTest"));
-    verifyNullCheckTest(classSubject.uniqueMethodWithName("nonNullCheckTest"));
+    verifyBooleanCheckTest(classSubject.uniqueMethodWithOriginalName("booleanCheckTest"));
+    verifyBooleanCheckTest(classSubject.uniqueMethodWithOriginalName("negateBooleanCheckTest"));
+    verifyIntCheckTest(classSubject.uniqueMethodWithOriginalName("intCheckTest"));
+    verifyIntCheckTest(classSubject.uniqueMethodWithOriginalName("negateIntCheckTest"));
+    verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("nullCheckTest"));
+    verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("invertedNullCheckTest"));
+    verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("nonNullCheckTest"));
     verifyNullCheckWithWrongTypeTest(
-        classSubject.uniqueMethodWithName("nullCheckWithWrongTypeTest"));
+        classSubject.uniqueMethodWithOriginalName("nullCheckWithWrongTypeTest"));
   }
 
   private void verifyBooleanCheckTest(MethodSubject methodSubject) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
index 3d3db4a..0134f78 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
@@ -117,6 +117,6 @@
       assertEquals("java.lang.Exception", guard.toSourceString());
     }
 
-    assertThat(classSubject.uniqueMethodWithName("foo"), isAbsent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), isAbsent());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
index 283718d..6654e42 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
@@ -67,9 +67,9 @@
         .inspect(
             inspector -> {
               ClassSubject clazz = inspector.clazz(TestClass.class);
-              assertThat(clazz.uniqueMethodWithName("bootstrap"), isPresent());
-              assertThat(clazz.uniqueMethodWithName("bar"), isPresent());
-              assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("bootstrap"), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName("bar"), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
index e3afc1c..051b633 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
@@ -81,7 +81,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Can optimize branches since `arg` is definitely null.
     assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -89,7 +89,7 @@
     ClassSubject bSub = inspector.clazz(BSub.class);
     assertThat(bSub, isPresent());
 
-    MethodSubject bSub_m = bSub.uniqueMethodWithName("m");
+    MethodSubject bSub_m = bSub.uniqueMethodWithOriginalName("m");
     assertThat(bSub_m, isPresent());
     // Can optimize branches since `arg` is definitely null.
     assertTrue(bSub_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
     ClassSubject c = inspector.clazz(C.class);
     assertThat(c, isPresent());
 
-    MethodSubject c_m = c.uniqueMethodWithName("m");
+    MethodSubject c_m = c.uniqueMethodWithOriginalName("m");
     assertThat(c_m, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(c_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
index 847bf55..2127c35 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
@@ -76,7 +76,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Can optimize branches since `arg` is definitely null.
     assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -84,7 +84,7 @@
     ClassSubject bSub = inspector.clazz(BSub.class);
     assertThat(bSub, isPresent());
 
-    MethodSubject bSub_m = bSub.uniqueMethodWithName("m");
+    MethodSubject bSub_m = bSub.uniqueMethodWithOriginalName("m");
     assertThat(bSub_m, isPresent());
     // Can optimize branches since `arg` is definitely null.
     assertTrue(bSub_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -92,7 +92,7 @@
     ClassSubject c = inspector.clazz(C.class);
     assertThat(c, isPresent());
 
-    MethodSubject c_m = c.uniqueMethodWithName("m");
+    MethodSubject c_m = c.uniqueMethodWithOriginalName("m");
     assertThat(c_m, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(c_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
index 25f6b89..cb43b17 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
@@ -61,7 +61,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject m = a.uniqueMethodWithName("m");
+    MethodSubject m = a.uniqueMethodWithOriginalName("m");
     assertThat(m, isPresent());
     // Should not optimize branches since the method is kept, accessed via reflection.
     assertTrue(m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
index e4b5197..b0f6cc4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
@@ -76,7 +76,7 @@
     ClassSubject customPredicate = inspector.clazz(CustomPredicate.class);
     assertThat(customPredicate, isPresent());
 
-    MethodSubject m = customPredicate.uniqueMethodWithName("test");
+    MethodSubject m = customPredicate.uniqueMethodWithOriginalName("test");
     // Should not optimize branches since the method is overriding a library method.
     assertTrue(m.streamInstructions().anyMatch(InstructionSubject::isIf));
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
index 3dc868d..8f500e1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
@@ -59,7 +59,7 @@
     // Check if the candidate is indeed staticized.
     ClassSubject companion = inspector.clazz(Host.Companion.class);
     assertThat(companion, isPresent());
-    MethodSubject foo = companion.uniqueMethodWithName("foo");
+    MethodSubject foo = companion.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     assertThat(foo, isStatic());
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
index f55c70b..b35e0e3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
@@ -65,7 +65,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
index 2c79f4c..47682c0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
@@ -60,7 +60,7 @@
     assertThat(mainMethodSubject, isPresent());
     assertTrue(mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isConstString));
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     assertEquals(0, test.getProgramMethod().getReference().getArity());
     // Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
index ca24f1f..8e5efc5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
@@ -73,7 +73,7 @@
     assertThat(i, isPresent());
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
index d1a160a..fe2bf46 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
@@ -82,14 +82,14 @@
     ClassSubject i = inspector.clazz(I.class);
     assertThat(i, isPresent());
 
-    MethodSubject i_m = i.uniqueMethodWithName("m");
+    MethodSubject i_m = i.uniqueMethodWithOriginalName("m");
     assertThat(i_m, isPresent());
     assertEquals(0, i_m.getProgramMethod().getReference().getArity());
 
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     assertEquals(0, a_m.getProgramMethod().getReference().getArity());
     // Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
@@ -98,7 +98,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     assertEquals(0, b_m.getProgramMethod().getReference().getArity());
     // Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
index 5c80990..861720e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
@@ -63,7 +63,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
index 9f01b31..a6b2376 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
@@ -59,7 +59,7 @@
       assertTrue(
           mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isConstString));
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     assertEquals(0, test.getProgramMethod().getReference().getArity());
     // Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
index 51593ba..0567d5d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
@@ -79,7 +79,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -87,7 +87,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
index 1c5689d..cb0a8e3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
@@ -74,7 +74,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
     assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -82,7 +82,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the value of `arg` is unsure.
     assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
index 76daffe..5321514 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
@@ -65,7 +65,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Should not optimize branches since the type of `arg` is unsure.
     assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
index ef373cd..ad78a71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
@@ -91,7 +91,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Can optimize branches since the type of `arg` is Sub1.
     assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
index 9fe54b4..dafde62 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
@@ -73,7 +73,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the type of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
index fd6b29e..e2d2d9a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
@@ -89,7 +89,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Can optimize branches since the type of `arg` is Sub1.
     assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the type of `arg` is unsure.
     assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
index 2055210..d57418e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
@@ -63,7 +63,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
 
     // Should not optimize branches since the type of `arg` is unsure.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
index 2dafd1b..fbc799b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
@@ -79,7 +79,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
 
     // Can optimize branches since the type of `arg` is Sub1.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
index b419ad2..a2325c8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
@@ -77,7 +77,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the type of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -85,7 +85,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the type of `arg` is unsure.
     assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
index 382be79..d580a1b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
@@ -89,7 +89,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Can optimize branches since the type of `arg` is Sub1.
     assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Can optimize branches since the type of `arg` is Sub1.
     assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
index 3a3a62d..a95bac2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
@@ -61,7 +61,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
index 11c44ad..94ba810 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
@@ -64,7 +64,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
index a80798a..485b02e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
@@ -81,7 +81,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
index b3988ee..4f34bad 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
@@ -73,7 +73,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -81,7 +81,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
index 6175434..64f0588 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
@@ -57,7 +57,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
index d181d3b..c81ec91 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
@@ -62,7 +62,7 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject test = main.uniqueMethodWithName("test");
+    MethodSubject test = main.uniqueMethodWithOriginalName("test");
     assertThat(test, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
index 60e3dd8..3606473 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
@@ -53,14 +53,14 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
       assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
 
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
index 08bd75c..9e4b9f5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
@@ -84,7 +84,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -92,7 +92,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
index c1c88a2..ecd71d8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
@@ -79,7 +79,7 @@
     ClassSubject a = inspector.clazz(A.class);
     assertThat(a, isPresent());
 
-    MethodSubject a_m = a.uniqueMethodWithName("m");
+    MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
     assertThat(a_m, isPresent());
     // Can optimize branches since `arg` is definitely not null.
     assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -87,7 +87,7 @@
     ClassSubject b = inspector.clazz(B.class);
     assertThat(b, isPresent());
 
-    MethodSubject b_m = b.uniqueMethodWithName("m");
+    MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
     assertThat(b_m, isPresent());
     // Should not optimize branches since the nullability of `arg` is unsure.
     assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
index 7d99b55..11a24ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
@@ -52,7 +52,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(Main.class);
               assertThat(clazz, isPresent());
-              MethodSubject testSubject = clazz.uniqueMethodWithName("test");
+              MethodSubject testSubject = clazz.uniqueMethodWithOriginalName("test");
               assertThat(testSubject, isPresent());
               Optional<InstructionSubject> insertedMonitor =
                   testSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
index 709a44b..c2e5e06 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
@@ -54,7 +54,7 @@
     ClassSubject enumSubject = inspector.clazz(MyEnum.class);
     assertThat(enumSubject, isPresent());
 
-    FieldSubject enumFieldSubject = enumSubject.uniqueFieldWithName("A");
+    FieldSubject enumFieldSubject = enumSubject.uniqueFieldWithOriginalName("A");
     assertThat(enumFieldSubject, isPresent());
 
     ClassSubject enumWithClassInitializationSideEffectsSubject =
@@ -62,7 +62,7 @@
     assertThat(enumWithClassInitializationSideEffectsSubject, isPresent());
 
     FieldSubject enumWithClassInitializationSideEffectsFieldSubject =
-        enumWithClassInitializationSideEffectsSubject.uniqueFieldWithName("A");
+        enumWithClassInitializationSideEffectsSubject.uniqueFieldWithOriginalName("A");
     assertThat(enumWithClassInitializationSideEffectsFieldSubject, isPresent());
 
     MethodSubject mainMethodSubject = classSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
index bc04d7e..ff6a112 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
@@ -141,7 +141,7 @@
       }
     }
 
-    MethodSubject sync = mainClass.uniqueMethodWithName("sync");
+    MethodSubject sync = mainClass.uniqueMethodWithOriginalName("sync");
     assertThat(sync, isPresent());
     count = Streams.stream(sync.iterateInstructions(
         i -> i.isConstString("", JumboStringMode.ALLOW))).count();
@@ -169,7 +169,7 @@
       }
     }
 
-    MethodSubject oom = mainClass.uniqueMethodWithName("oom");
+    MethodSubject oom = mainClass.uniqueMethodWithOriginalName("oom");
     assertThat(oom, isPresent());
     count = Streams.stream(oom.iterateInstructions(
         i -> i.isConstString("this-string-will-not-be-loaded.", JumboStringMode.ALLOW))).count();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
index 1f7b39a..5dc2510 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
@@ -55,7 +55,7 @@
             codeInspector -> {
               ClassSubject main = codeInspector.clazz(Main.class);
               assertThat(main, isPresent());
-              MethodSubject mainMethod = main.uniqueMethodWithName("main");
+              MethodSubject mainMethod = main.uniqueMethodWithOriginalName("main");
               assertThat(mainMethod, isPresent());
               assertEquals(
                   0,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
index a1577a3..659764a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
@@ -52,16 +52,16 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     MethodSubject trivialCastMethodSubject =
-        classSubject.uniqueMethodWithName("trivialCastAfterBranchPruningTest");
+        classSubject.uniqueMethodWithOriginalName("trivialCastAfterBranchPruningTest");
     assertThat(trivialCastMethodSubject, isPresent());
     assertTrue(
         trivialCastMethodSubject.streamInstructions().noneMatch(InstructionSubject::isCheckCast));
 
     MethodSubject branchPruningMethodSubject =
-        classSubject.uniqueMethodWithName("branchPruningAfterInstanceOfOptimization");
+        classSubject.uniqueMethodWithOriginalName("branchPruningAfterInstanceOfOptimization");
     assertThat(branchPruningMethodSubject, isPresent());
     assertTrue(
         branchPruningMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
index 2922b90..30dd4b4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
@@ -72,7 +72,7 @@
 
     // No instructions can read field f1 before it is assigned, and therefore, we can safely
     // remove the static-put instruction and update the static value of the field.
-    FieldSubject f1FieldSubject = testClassSubject.uniqueFieldWithName("f1");
+    FieldSubject f1FieldSubject = testClassSubject.uniqueFieldWithOriginalName("f1");
     assertThat(f1FieldSubject, isPresent());
     assertNotNull(f1FieldSubject.getField().getStaticValue());
     assertTrue(f1FieldSubject.getField().getStaticValue().isDexValueInt());
@@ -80,7 +80,7 @@
 
     // Field f3 is assigned after an instruction that could read it, and therefore, we cannot safely
     // remove the static-put instruction and update the static value of the field.
-    FieldSubject f3FieldSubject = testClassSubject.uniqueFieldWithName("f3");
+    FieldSubject f3FieldSubject = testClassSubject.uniqueFieldWithOriginalName("f3");
     assertThat(f3FieldSubject, isPresent());
     assertNotNull(f3FieldSubject.getField().getStaticValue());
     assertTrue(f3FieldSubject.getField().getStaticValue().isDexValueInt());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
index 16aac95..92383ae 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
@@ -73,7 +73,7 @@
             .inspector();
     ClassSubject clazz = inspector.clazz(Keeper.class);
     assertThat(clazz, isPresent());
-    MethodSubject main = clazz.uniqueMethodWithName("main");
+    MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
     assertTrue(main.streamInstructions().noneMatch(i -> i.isConstString(JumboStringMode.ALLOW)));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
index efdaea1..c0daee1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
@@ -82,9 +82,9 @@
     assertThat(inspector.clazz(PairBuilder.class), not(isPresent()));
 
     Set<String> expected = ImmutableSet.of(StringBuilder.class.getTypeName());
-    assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder1")));
-    assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder2")));
-    assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder3")));
+    assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder1")));
+    assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder2")));
+    assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder3")));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
index cd28e2a..c79c42e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
@@ -53,13 +53,13 @@
     assertTrue(
         inspector
             .clazz(TestClass.class)
-            .uniqueMethodWithName("produce1")
+            .uniqueMethodWithOriginalName("produce1")
             .streamInstructions()
             .anyMatch(InstructionSubject::isMonitorEnter));
     assertTrue(
         inspector
             .clazz(TestClass.class)
-            .uniqueMethodWithName("produce2")
+            .uniqueMethodWithOriginalName("produce2")
             .streamInstructions()
             .anyMatch(InstructionSubject::isMonitorExit));
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
index 23c364e..a730b8a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
@@ -49,7 +49,8 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    assertThat(inspector.clazz(Container.class).uniqueMethodWithName("increment"), isPresent());
+    assertThat(
+        inspector.clazz(Container.class).uniqueMethodWithOriginalName("increment"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
index f858a0e..32be199 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
@@ -49,7 +49,8 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    assertThat(inspector.clazz(Container.class).uniqueMethodWithName("increment"), isPresent());
+    assertThat(
+        inspector.clazz(Container.class).uniqueMethodWithOriginalName("increment"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index 8e5d660..6c30034 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -109,50 +109,52 @@
 
     assertEquals(
         Collections.singleton("java.lang.StringBuilder"),
-        collectTypes(clazz.uniqueMethodWithName("testInner")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testInner")));
 
     assertEquals(
         Collections.emptySet(),
-        collectTypes(clazz.uniqueMethodWithName("testConstructorMapping1")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping1")));
 
     assertEquals(
         Collections.emptySet(),
-        collectTypes(clazz.uniqueMethodWithName("testConstructorMapping2")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping2")));
 
     assertEquals(
         Collections.singleton("java.lang.StringBuilder"),
-        collectTypes(clazz.uniqueMethodWithName("testConstructorMapping3")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping3")));
 
     assertEquals(
-        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testEmptyClass")));
+        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("testEmptyClass")));
 
     assertEquals(
         Collections.singleton(
             "com.android.tools.r8.ir.optimize.classinliner.trivial.EmptyClassWithInitializer"),
-        collectTypes(clazz.uniqueMethodWithName("testEmptyClassWithInitializer")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testEmptyClassWithInitializer")));
 
     assertEquals(
         Collections.singleton(
             "com.android.tools.r8.ir.optimize.classinliner.trivial.ClassWithFinal"),
-        collectTypes(clazz.uniqueMethodWithName("testClassWithFinalizer")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testClassWithFinalizer")));
 
     assertEquals(
-        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testCallOnIface1")));
+        Collections.emptySet(),
+        collectTypes(clazz.uniqueMethodWithOriginalName("testCallOnIface1")));
 
     assertEquals(
-        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testCallOnIface2")));
+        Collections.emptySet(),
+        collectTypes(clazz.uniqueMethodWithOriginalName("testCallOnIface2")));
 
     assertEquals(
         Sets.newHashSet(
             "com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceAB",
             "java.lang.StringBuilder"),
-        collectTypes(clazz.uniqueMethodWithName("testCycles")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testCycles")));
 
     assertEquals(
         Sets.newHashSet(
             "java.lang.StringBuilder",
             "com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceAB"),
-        collectTypes(inspector.clazz(CycleReferenceAB.class).uniqueMethodWithName("foo")));
+        collectTypes(inspector.clazz(CycleReferenceAB.class).uniqueMethodWithOriginalName("foo")));
 
     assertThat(inspector.clazz(CycleReferenceBA.class), isAbsent());
   }
@@ -219,11 +221,14 @@
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(C.class);
 
-    assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method1")));
+    assertEquals(
+        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method1")));
 
-    assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method2")));
+    assertEquals(
+        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method2")));
 
-    assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method3")));
+    assertEquals(
+        Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method3")));
 
     assertFalse(inspector.clazz(C.L.class).isPresent());
     assertFalse(inspector.clazz(C.F.class).isPresent());
@@ -264,15 +269,15 @@
     // TODO(b/143129517, 141719453): This expectation relies on the class inlining limits.
     assertEquals(
         Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
-        collectTypes(clazz.uniqueMethodWithName("testExtraNeverReturnsNormally")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testExtraNeverReturnsNormally")));
 
     assertEquals(
         Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
-        collectTypes(clazz.uniqueMethodWithName("testDirectNeverReturnsNormally")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testDirectNeverReturnsNormally")));
 
     assertEquals(
         Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
-        collectTypes(clazz.uniqueMethodWithName("testInitNeverReturnsNormally")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testInitNeverReturnsNormally")));
 
     assertThat(
         inspector.clazz(InvalidRootsTestClass.NeverReturnsNormally.class),
@@ -283,7 +288,7 @@
     // TODO(b/143129517, b/141719453): This expectation relies on the class inlining limits.
     assertEquals(
         Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
-        collectTypes(clazz.uniqueMethodWithName("testRootInvalidatesAfterInlining")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testRootInvalidatesAfterInlining")));
 
     assertThat(inspector.clazz(InvalidRootsTestClass.A.class), not(isPresent()));
     assertThat(inspector.clazz(InvalidRootsTestClass.B.class), not(isPresent()));
@@ -323,13 +328,13 @@
     // TODO(b/120814598): Should only be "java.lang.StringBuilder".
     assertEquals(
         new HashSet<>(synthesizedJavaLambdaClasses),
-        collectTypes(clazz.uniqueMethodWithName("testStatelessLambda")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testStatelessLambda")));
     assertTrue(
         inspector.allClasses().stream().anyMatch(ClassSubject::isSynthesizedJavaLambdaClass));
 
     assertEquals(
         Sets.newHashSet("java.lang.StringBuilder"),
-        collectTypes(clazz.uniqueMethodWithName("testStatefulLambda")));
+        collectTypes(clazz.uniqueMethodWithOriginalName("testStatefulLambda")));
   }
 
   private String getProguardConfig(String main) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
index 6fe9d09..809c81a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
@@ -57,7 +57,7 @@
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithName("m");
+    MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithOriginalName("m");
     assertThat(mMethodSubject, isPresent());
     assertFalse(mMethodSubject.getMethod().accessFlags.isSynthetic());
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
index e82bd6e..f3d1079 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
@@ -46,7 +46,8 @@
         .compile()
         .inspect(
             inspector -> {
-              MethodSubject fooMethod = inspector.clazz(Main.class).uniqueMethodWithName("foo");
+              MethodSubject fooMethod =
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
               assertThat(fooMethod, isPresent());
               assertThat(
                   fooMethod,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
index 2b6a5c8..bb751a2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
@@ -52,7 +52,7 @@
     CodeInspector inspector = result.inspector();
     ClassSubject mainSubject = inspector.clazz(MAIN);
     assertThat(mainSubject, isPresent());
-    MethodSubject methodSubject = mainSubject.uniqueMethodWithName("booRunner");
+    MethodSubject methodSubject = mainSubject.uniqueMethodWithOriginalName("booRunner");
     assertThat(methodSubject, isPresent());
     verifyNotDevirtualized(methodSubject);
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
index e4b2d91..82e963b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
@@ -60,14 +60,14 @@
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject negativeTestSubject = bClassSubject.uniqueMethodWithName("negativeTest");
+    MethodSubject negativeTestSubject = bClassSubject.uniqueMethodWithOriginalName("negativeTest");
     assertThat(negativeTestSubject, isPresent());
     assertTrue(negativeTestSubject.streamInstructions().anyMatch(this::isInvokeSuper));
     assertTrue(
         negativeTestSubject.streamInstructions().noneMatch(InstructionSubject::isInvokeVirtual));
 
     // B.positiveTest() is moved to A as a result of bridge hoisting.
-    MethodSubject positiveTestSubject = aClassSubject.uniqueMethodWithName("positiveTest");
+    MethodSubject positiveTestSubject = aClassSubject.uniqueMethodWithOriginalName("positiveTest");
     assertThat(positiveTestSubject, isPresent());
     assertTrue(positiveTestSubject.streamInstructions().noneMatch(this::isInvokeSuper));
     assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
index 6570849..a0bbdb1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
@@ -60,7 +60,7 @@
             inspector -> {
               ClassSubject classA = inspector.clazz(A.class);
               assertThat(classA, isPresent());
-              MethodSubject fooA = classA.uniqueMethodWithName("foo");
+              MethodSubject fooA = classA.uniqueMethodWithOriginalName("foo");
               assertThat(fooA, isPresent());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
index ca2d49a..daed986 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
@@ -66,7 +66,7 @@
 
     // Verify that the check-cast instruction is still present in testCheckCastRemoval().
     MethodSubject testCheckCastRemovalMethod =
-        mainClassSubject.uniqueMethodWithName("testCheckCastRemoval");
+        mainClassSubject.uniqueMethodWithOriginalName("testCheckCastRemoval");
     assertThat(testCheckCastRemovalMethod, isPresent());
     assertTrue(
         testCheckCastRemovalMethod
@@ -76,7 +76,7 @@
     // Verify that the instance-of instruction is only present in testInstanceOfRemoval() if the
     // dynamic type optimization is disabled.
     MethodSubject testInstanceOfRemovalMethod =
-        mainClassSubject.uniqueMethodWithName("testInstanceOfRemoval");
+        mainClassSubject.uniqueMethodWithOriginalName("testInstanceOfRemoval");
     assertThat(testInstanceOfRemovalMethod, isPresent());
     assertTrue(
         testInstanceOfRemovalMethod
@@ -86,18 +86,18 @@
     // Verify that world() has been inlined() into testMethodInlining() unless the dynamic type
     // optimization is disabled.
     MethodSubject testMethodInliningMethod =
-        mainClassSubject.uniqueMethodWithName("testMethodInlining");
+        mainClassSubject.uniqueMethodWithOriginalName("testMethodInlining");
     assertThat(testMethodInliningMethod, isPresent());
-    assertTrue(interfaceSubject.uniqueMethodWithName("world").isAbsent());
+    assertTrue(interfaceSubject.uniqueMethodWithOriginalName("world").isAbsent());
 
     // Verify that exclamationMark() has been rebound in testMethodRebinding() unless the dynamic
     // type optimization is disabled.
     MethodSubject testMethodRebindingMethod =
-        mainClassSubject.uniqueMethodWithName("testMethodRebinding");
+        mainClassSubject.uniqueMethodWithOriginalName("testMethodRebinding");
     assertThat(testMethodRebindingMethod, isPresent());
     assertThat(
         testMethodRebindingMethod,
-        invokesMethod(aClassSubject.uniqueMethodWithName("exclamationMark")));
+        invokesMethod(aClassSubject.uniqueMethodWithOriginalName("exclamationMark")));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
index 65cc34d..03c69b1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
@@ -67,15 +67,15 @@
 
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
-    assertThat(aClassSubject.uniqueMethodWithName("kept"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
-    assertThat(bClassSubject.uniqueMethodWithName("kept"), isPresent());
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
 
     // A.notKept() and B.notKept() should not be present, because the only invoke instruction
     // targeting A.notKept() should have been inlined.
-    assertThat(aClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
index 89586d8..c073c8b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
@@ -65,15 +65,15 @@
 
   private void inspect(CodeInspector inspector) {
     ClassSubject iClassSubject = inspector.clazz(I.class);
-    assertThat(iClassSubject.uniqueMethodWithName("kept"), isPresent());
+    assertThat(iClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
-    assertThat(aClassSubject.uniqueMethodWithName("kept"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
 
     // I.notKept() and A.notKept() should not be present, because the only invoke instruction
     // targeting I.notKept() should have been inlined.
-    assertThat(iClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
-    assertThat(aClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
+    assertThat(iClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
index 53a83d5..4b60883 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
@@ -90,7 +90,7 @@
       String methodName,
       boolean isNPEWithMessage,
       boolean shouldBeOptimized) {
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
     assertThat(methodSubject, isPresent());
 
     IRCode code = methodSubject.buildIR();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
index a8bccea..1225b7f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
@@ -50,8 +50,8 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
     assertThat(testClassSubject.mainMethod(), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
index 5e5f50c..3d520ac 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
@@ -42,7 +42,7 @@
         .inspect(
             inspector ->
                 assertThat(
-                    inspector.clazz(Main.class).uniqueMethodWithName("dead"),
+                    inspector.clazz(Main.class).uniqueMethodWithOriginalName("dead"),
                     not(invokesMethodWithName("dead"))))
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello world!");
@@ -58,7 +58,8 @@
         .compile()
         .inspect(
             inspector ->
-                assertThat(inspector.clazz(Main.class).uniqueMethodWithName("dead"), isAbsent()))
+                assertThat(
+                    inspector.clazz(Main.class).uniqueMethodWithOriginalName("dead"), isAbsent()))
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello world!");
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
index 527d320..94c8213 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
@@ -84,7 +84,7 @@
     assertThat(otherClassSubject, isPresent());
 
     // Method A.m() should no longer be present due to inlining.
-    assertThat(otherClassSubject.uniqueMethodWithName("m"), not(isPresent()));
+    assertThat(otherClassSubject.uniqueMethodWithOriginalName("m"), not(isPresent()));
   }
 
   private boolean canUseRequireNonNull() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
index 634d0a8..2dee8a7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
@@ -52,7 +52,10 @@
         .inspect(
             inspector -> {
               MethodSubject methodSubject =
-                  inspector.clazz(TestClass.class).uniqueMethodWithName("main").asMethodSubject();
+                  inspector
+                      .clazz(TestClass.class)
+                      .uniqueMethodWithOriginalName("main")
+                      .asMethodSubject();
 
               counts.run = countInvokesWithName(methodSubject, "run");
               counts.println = countInvokesWithName(methodSubject, "println");
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 53fa602..ed2f50d 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
@@ -55,7 +55,7 @@
         .inspect(
             inspector ->
                 assertThat(
-                    inspector.clazz(TestClass.class).uniqueMethodWithName("test"),
+                    inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("test"),
                     not(isPresent())));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
index b2fe085..e4ad5b8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
@@ -38,11 +38,11 @@
 
     // Verify that greet() is not inlined into main() -- that would lead to illegal access errors
     // since main() does not have access to the GreetingBase.greeting field.
-    assertThat(greeterSubject.uniqueMethodWithName("greet"), isPresent());
+    assertThat(greeterSubject.uniqueMethodWithOriginalName("greet"), isPresent());
 
     // The method greetInternal() should be inlined into greet() since it has a single call site and
     // nothing prevents it from being inlined.
-    assertThat(greeterSubject.uniqueMethodWithName("greetInternal"), not(isPresent()));
+    assertThat(greeterSubject.uniqueMethodWithOriginalName("greetInternal"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
index 45997a8..d2e9063 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
@@ -46,7 +46,7 @@
                   2,
                   inspector
                       .clazz(TestClass.class)
-                      .uniqueMethodWithName("main")
+                      .uniqueMethodWithOriginalName("main")
                       .streamInstructions()
                       .filter(i -> i.isMonitorEnter() || i.isMonitorExit())
                       .count());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
index 1cb4d4f..7fd5b34 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
@@ -71,7 +71,7 @@
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertThat(
-                  aClassSubject.uniqueMethodWithName("normalInlinedSynchronized"),
+                  aClassSubject.uniqueMethodWithOriginalName("normalInlinedSynchronized"),
                   not(isPresent()));
 
               ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
index be2ffe2..960e3d9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
@@ -69,7 +69,7 @@
                   assertTrue(
                       inspector
                           .clazz(Main.class)
-                          .uniqueMethodWithName("main")
+                          .uniqueMethodWithOriginalName("main")
                           .streamInstructions()
                           .anyMatch(InstructionSubject::isThrow));
                 })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
index db81629..b9a6aa4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
@@ -61,13 +61,15 @@
               ClassSubject mainClassSubject = inspector.clazz(ExceptionHandlingTestClass.class);
               assertThat(mainClassSubject, isPresent());
               assertThat(
-                  mainClassSubject.uniqueMethodWithName("inlineeWithNormalExitThatDoesNotThrow"),
+                  mainClassSubject.uniqueMethodWithOriginalName(
+                      "inlineeWithNormalExitThatDoesNotThrow"),
                   isAbsent());
               assertThat(
-                  mainClassSubject.uniqueMethodWithName("inlineeWithNormalExitThatThrows"),
+                  mainClassSubject.uniqueMethodWithOriginalName("inlineeWithNormalExitThatThrows"),
                   isAbsent());
               assertThat(
-                  mainClassSubject.uniqueMethodWithName("inlineeWithoutNormalExit"), isAbsent());
+                  mainClassSubject.uniqueMethodWithOriginalName("inlineeWithoutNormalExit"),
+                  isAbsent());
             })
         .run(ExceptionHandlingTestClass.class)
         .assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
index b4c0a63..c93ceea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
@@ -51,10 +51,10 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
 
-    MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+    MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
     assertThat(notInlineableMethod, isPresent());
 
     MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -73,7 +73,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
@@ -86,7 +86,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
@@ -101,7 +101,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
@@ -114,7 +114,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
@@ -127,10 +127,10 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+    MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
     assertThat(notInlineableMethod, isPresent());
 
-    MethodSubject testMethod = inspector.clazz(mainClass).uniqueMethodWithName("test");
+    MethodSubject testMethod = inspector.clazz(mainClass).uniqueMethodWithOriginalName("test");
     assertThat(testMethod, isPresent());
     assertThat(testMethod, invokesMethod(notInlineableMethod));
   }
@@ -150,7 +150,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
@@ -166,10 +166,11 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+    MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
     assertThat(notInlineableMethod, isPresent());
 
-    MethodSubject alsoNotInlineableMethod = classA.uniqueMethodWithName("alsoNotInlineable");
+    MethodSubject alsoNotInlineableMethod =
+        classA.uniqueMethodWithOriginalName("alsoNotInlineable");
     assertThat(alsoNotInlineableMethod, isPresent());
 
     MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -189,7 +190,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+    MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
     assertThat(notInlineableMethod, isPresent());
 
     MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -206,7 +207,7 @@
     ClassSubject classA = inspector.clazz(A.class);
     assertThat(classA, isPresent());
 
-    MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
index f70aebe..448a7b7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
@@ -69,19 +69,19 @@
     ClassSubject classC = inspector.clazz(C.class);
     assertThat(classC, isPresent());
 
-    MethodSubject testMethod = classB.uniqueMethodWithName("test");
+    MethodSubject testMethod = classB.uniqueMethodWithOriginalName("test");
     assertThat(testMethod, isPresent());
 
-    MethodSubject inlineable1Method = classA.uniqueMethodWithName("inlineable1");
+    MethodSubject inlineable1Method = classA.uniqueMethodWithOriginalName("inlineable1");
     assertThat(inlineable1Method, not(isPresent()));
 
-    MethodSubject inlineable2Method = classB.uniqueMethodWithName("inlineable2");
+    MethodSubject inlineable2Method = classB.uniqueMethodWithOriginalName("inlineable2");
     assertThat(inlineable2Method, not(isPresent()));
 
     MethodSubject inlineableWithInitClassMethod =
-        classC.uniqueMethodWithName("inlineableWithInitClass");
+        classC.uniqueMethodWithOriginalName("inlineableWithInitClass");
     assertThat(inlineableWithInitClassMethod, not(isPresent()));
-    assertThat(testMethod, accessesField(classC.uniqueFieldWithName("$r8$clinit")));
+    assertThat(testMethod, accessesField(classC.uniqueFieldWithOriginalName("$r8$clinit")));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
index 841c369..19806fb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
@@ -68,7 +68,7 @@
       ClassSubject classSubject = result.inspector().clazz(getClassA());
       assertThat(classSubject, isPresent());
 
-      MethodSubject methodSubject = classSubject.uniqueMethodWithName("method");
+      MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("method");
       assertEquals(neverInline, methodSubject.isPresent());
     }
 
@@ -79,7 +79,7 @@
           result.inspector().clazz(InliningIntoVisibilityBridgeTestClassB.class);
       assertThat(classSubject, isPresent());
 
-      MethodSubject methodSubject = classSubject.uniqueMethodWithName("method");
+      MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("method");
       if (!neverInline) {
         assertThat(methodSubject, isPresentAndRenamed());
         assertFalse(methodSubject.isBridge());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
index cc347c5..2350b12 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
@@ -51,9 +51,9 @@
   private void verifyOutput(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("foo"), not(isPresent()));
-    assertThat(classSubject.uniqueMethodWithName("bar"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("baz"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("bar"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("baz"), isPresent());
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
index ab412be..4694c08 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
@@ -42,10 +42,10 @@
     ClassSubject classB = inspector.clazz(B.class);
     assertThat(classB, isPresent());
 
-    MethodSubject inlineableMethod = classB.uniqueMethodWithName("inlineable");
+    MethodSubject inlineableMethod = classB.uniqueMethodWithOriginalName("inlineable");
     assertThat(inlineableMethod, not(isPresent()));
 
-    MethodSubject otherMethod = classB.uniqueMethodWithName("other");
+    MethodSubject otherMethod = classB.uniqueMethodWithOriginalName("other");
     assertThat(otherMethod, isPresent());
 
     MethodSubject mainMethod = inspector.clazz(TestClass.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
index 3882a7b..dea2a26 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
@@ -47,7 +47,7 @@
               assertThat(greeterClassSubject, isPresent());
 
               MethodSubject toStringMethodSubject =
-                  greeterClassSubject.uniqueMethodWithName("toString");
+                  greeterClassSubject.uniqueMethodWithOriginalName("toString");
               assertThat(toStringMethodSubject, isPresent());
 
               ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
index 09bb71b..09f4c9b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
@@ -71,7 +71,7 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("m");
+    MethodSubject methodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
     assertThat(methodSubject, isPresent());
     assertEquals(
         5,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
index e0a1d16..9fae6b0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
@@ -65,16 +65,16 @@
     assertThat(testClassSubject, isPresent());
 
     // The indirection() method should be inlined.
-    assertThat(testClassSubject.uniqueMethodWithName("indirection"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("indirection"), not(isPresent()));
 
     // A.foo() should be absent if the max inlining depth is 1, because indirection() has been
     // inlined into main(), which makes A.foo() eligible for inlining into main().
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("foo"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
 
     // A.bar() should always be inlined because it is marked as @AlwaysInline.
-    assertThat(aClassSubject.uniqueMethodWithName("bar"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("bar"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
index e7b6931..4dcba65 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
@@ -68,19 +68,25 @@
   private void verifyOnlyCanBeInlinedHasBeenInlined(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("canBeInlined"), not(isPresent()));
-    assertThat(aClassSubject.uniqueMethodWithName("canBeInlinedDueToAssume"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("canBeInlined"), not(isPresent()));
     assertThat(
-        aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule"), isPresent());
+        aClassSubject.uniqueMethodWithOriginalName("canBeInlinedDueToAssume"), not(isPresent()));
+    assertThat(
+        aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch"),
+        isPresent());
+    assertThat(
+        aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("canBeInlined"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("canBeInlinedDueToAssume"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("canBeInlined"), not(isPresent()));
     assertThat(
-        bClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch"), isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule"), isPresent());
+        bClassSubject.uniqueMethodWithOriginalName("canBeInlinedDueToAssume"), not(isPresent()));
+    assertThat(
+        bClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch"),
+        isPresent());
+    assertThat(
+        bClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule"), isPresent());
 
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
@@ -100,10 +106,11 @@
     }
     assertThat(
         mainMethodSubject,
-        invokesMethod(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch")));
+        invokesMethod(
+            aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch")));
     assertThat(
         mainMethodSubject,
-        invokesMethod(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule")));
+        invokesMethod(aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule")));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
index c55ea29..96f9184 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
@@ -50,11 +50,11 @@
               assertThat(mainClassSubject, isPresent());
 
               // Method doStuff() is inlined into main().
-              assertThat(mainClassSubject.uniqueMethodWithName("doStuff"), isAbsent());
+              assertThat(mainClassSubject.uniqueMethodWithOriginalName("doStuff"), isAbsent());
 
               // Method checkNotNull() is not inlined.
               MethodSubject checkNotNullMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("checkNotNull");
+                  mainClassSubject.uniqueMethodWithOriginalName("checkNotNull");
               assertThat(checkNotNullMethodSubject, isPresent());
 
               // There is a single call to checkNotNull() in main(), as checkNotNull(newObject())
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
index f75c4c8..685036d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
@@ -80,10 +80,10 @@
     }
 
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfNullTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfBothNullTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfNotNullTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfBothNotNullTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfNullTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothNullTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfNotNullTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothNotNullTest"), isPresent());
   }
 
   private boolean shouldBeEligibleForSimpleInlining() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
index 180b971..18804c7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
@@ -80,10 +80,10 @@
     }
 
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfTrueTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfBothTrueTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfFalseTest"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("simpleIfBothFalseTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfTrueTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothTrueTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfFalseTest"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothFalseTest"), isPresent());
   }
 
   private boolean shouldBeEligibleForSimpleInlining() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
index 8a606a7..1a20851 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
@@ -53,8 +53,8 @@
   private void verifySynchronizedMethodsAreInlined(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(RunnableImpl.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("m1"), not(isPresent()));
-    assertThat(classSubject.uniqueMethodWithName("m2"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
index 6ac9e07..d6c07ca 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
@@ -54,13 +54,13 @@
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
     assertThat(classSubject.mainMethod(), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("m1"), not(isPresent()));
-    assertThat(classSubject.uniqueMethodWithName("m2"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
     if (threshold == 2) {
-      assertThat(classSubject.uniqueMethodWithName("m3"), isPresent());
+      assertThat(classSubject.uniqueMethodWithOriginalName("m3"), isPresent());
     } else {
       assert threshold == 3;
-      assertThat(classSubject.uniqueMethodWithName("m3"), not(isPresent()));
+      assertThat(classSubject.uniqueMethodWithOriginalName("m3"), not(isPresent()));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
index 09aef4c..aa2e06a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
@@ -167,14 +167,14 @@
     ClassSubject testClass = inspector.clazz(TestClass.class);
 
     // With inlining we can prove that all instance-of checks succeed or fail.
-    MethodSubject fooMethodSubject = testClass.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = testClass.uniqueMethodWithOriginalName("foo");
     Iterator<InstructionSubject> fooInstructionIterator =
         fooMethodSubject.iterateInstructions(InstructionSubject::isInstanceOf);
     assertEquals(0, Streams.stream(fooInstructionIterator).count());
 
     // Without inlining we cannot prove any of the instance-of checks to be trivial, but the dynamic
     // type optimization allows us to prove that some are safe.
-    MethodSubject barMethodSubject = testClass.uniqueMethodWithName("bar");
+    MethodSubject barMethodSubject = testClass.uniqueMethodWithOriginalName("bar");
     Iterator<InstructionSubject> barInstructionIterator =
         barMethodSubject.iterateInstructions(InstructionSubject::isInstanceOf);
     assertEquals(2, Streams.stream(barInstructionIterator).count());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
index b6ca59d..35eb0d0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
@@ -56,7 +56,7 @@
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
 
-    MethodSubject testClassMethodSubject = classSubject.uniqueMethodWithName("testClass");
+    MethodSubject testClassMethodSubject = classSubject.uniqueMethodWithOriginalName("testClass");
     assertThat(testClassMethodSubject, isPresent());
     assertTrue(
         testClassMethodSubject
@@ -70,7 +70,7 @@
                     instruction.isInvokeVirtual()
                         && instruction.getMethod().toSourceString().contains("println")));
 
-    MethodSubject testLambdaMethodSubject = classSubject.uniqueMethodWithName("testLambda");
+    MethodSubject testLambdaMethodSubject = classSubject.uniqueMethodWithOriginalName("testLambda");
     assertThat(testLambdaMethodSubject, isPresent());
     assertTrue(
         testLambdaMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
index 24894bb..400e662 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
@@ -68,7 +68,7 @@
     assertThat(testClassSubject, isPresent());
 
     MethodSubject testOptimizedMethodSubject =
-        testClassSubject.uniqueMethodWithName("testOptimized");
+        testClassSubject.uniqueMethodWithOriginalName("testOptimized");
     assertThat(testOptimizedMethodSubject, isPresent());
     assertTrue(
         testOptimizedMethodSubject
@@ -79,7 +79,7 @@
             .noneMatch(method -> method.contains("parseBoolean")));
 
     MethodSubject testNotOptimizedMethodSubject =
-        testClassSubject.uniqueMethodWithName("testNotOptimized");
+        testClassSubject.uniqueMethodWithOriginalName("testNotOptimized");
     assertThat(testNotOptimizedMethodSubject, isPresent());
     assertEquals(
         1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
index 85eb82b..a260221 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
@@ -53,7 +53,7 @@
     assertThat(testClassSubject, isPresent());
 
     MethodSubject testBooleanValueOfTrue =
-        testClassSubject.uniqueMethodWithName("testBooleanValueOfTrue");
+        testClassSubject.uniqueMethodWithOriginalName("testBooleanValueOfTrue");
     assertThat(testBooleanValueOfTrue, isPresent());
     assertTrue(
         testBooleanValueOfTrue
@@ -69,7 +69,7 @@
             .noneMatch("TRUE"::equals));
 
     MethodSubject testBooleanValueOfFalse =
-        testClassSubject.uniqueMethodWithName("testBooleanValueOfFalse");
+        testClassSubject.uniqueMethodWithOriginalName("testBooleanValueOfFalse");
     assertThat(testBooleanValueOfFalse, isPresent());
     assertTrue(
         testBooleanValueOfFalse
@@ -85,7 +85,7 @@
             .noneMatch("FALSE"::equals));
 
     MethodSubject testRoundTripTrueMethodSubject =
-        testClassSubject.uniqueMethodWithName("testRoundTripTrue");
+        testClassSubject.uniqueMethodWithOriginalName("testRoundTripTrue");
     assertThat(testRoundTripTrueMethodSubject, isPresent());
     assertTrue(
         testRoundTripTrueMethodSubject
@@ -95,7 +95,7 @@
             .noneMatch(or("booleanValue"::equals, "valueOf"::equals)));
 
     MethodSubject testRoundTripFalseMethodSubject =
-        testClassSubject.uniqueMethodWithName("testRoundTripFalse");
+        testClassSubject.uniqueMethodWithOriginalName("testRoundTripFalse");
     assertThat(testRoundTripFalseMethodSubject, isPresent());
     assertTrue(
         testRoundTripFalseMethodSubject
@@ -104,7 +104,8 @@
             .map(invoke -> invoke.getMethod().name.toSourceString())
             .noneMatch(or("booleanValue"::equals, "valueOf"::equals)));
 
-    MethodSubject testValueOfTrue = testClassSubject.uniqueMethodWithName("testValueOfTrue");
+    MethodSubject testValueOfTrue =
+        testClassSubject.uniqueMethodWithOriginalName("testValueOfTrue");
     assertThat(testValueOfTrue, isPresent());
     assertTrue(
         testValueOfTrue
@@ -119,7 +120,8 @@
             .map(staticGet -> staticGet.getField().name.toSourceString())
             .anyMatch("TRUE"::equals));
 
-    MethodSubject testValueOfFalse = testClassSubject.uniqueMethodWithName("testValueOfFalse");
+    MethodSubject testValueOfFalse =
+        testClassSubject.uniqueMethodWithOriginalName("testValueOfFalse");
     assertThat(testValueOfFalse, isPresent());
     assertTrue(
         testValueOfFalse
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
index 109c991..6e09e0c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
@@ -55,7 +55,7 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentsMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArguments");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArguments");
               assertThat(testNonNullArgumentsMethodSubject, isPresent());
               assertThat(
                   testNonNullArgumentsMethodSubject,
@@ -65,19 +65,19 @@
                   invokesMethodWithHolderAndName("java.lang.Object", "equals"));
 
               MethodSubject testNullAndNullArgumentsMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullAndNullArguments");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullAndNullArguments");
               assertThat(testNullAndNullArgumentsMethodSubject, isPresent());
               assertThat(
                   testNullAndNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
 
               MethodSubject testNullAndNonNullArgumentsMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullAndNonNullArguments");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullAndNonNullArguments");
               assertThat(testNullAndNonNullArgumentsMethodSubject, isPresent());
               assertThat(
                   testNullAndNonNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
 
               MethodSubject testNullAndMaybeNullArgumentsMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullAndMaybeNullArguments");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullAndMaybeNullArguments");
               assertThat(testNullAndMaybeNullArgumentsMethodSubject, isPresent());
               assertThat(
                   testNullAndMaybeNullArgumentsMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
index 8ed1eac..680be9d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
@@ -51,14 +51,14 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(
                   testNonNullArgumentMethodSubject,
                   not(invokesMethodWithHolderAndName("java.util.Objects", "hashCode")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("hashCode")));
             })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
index 6064fec..9053ad5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
@@ -48,12 +48,12 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
             })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
index d4b4d35..e1b3b14 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
@@ -48,12 +48,12 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
             })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
index aadd5dd..a2391f0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
@@ -64,14 +64,14 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(
                   testNonNullArgumentMethodSubject,
                   not(invokesMethodWithName("requireNonNullElseGet")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(
                   testNullArgumentMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
index bde8237..7b4ed4b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
@@ -59,14 +59,14 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(
                   testNonNullArgumentMethodSubject,
                   not(invokesMethodWithName("requireNonNullElse")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(
                   testNullArgumentMethodSubject, not(invokesMethodWithName("requireNonNullElse")));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
index fe974a5..aed86f3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
@@ -53,12 +53,12 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject testNonNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
               assertThat(testNonNullArgumentMethodSubject, isPresent());
               assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
 
               MethodSubject testNullArgumentMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+                  mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
               assertThat(testNullArgumentMethodSubject, isPresent());
               assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
             })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
index 5dc83d0..9d6fe46 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
@@ -48,8 +48,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
index edd2219..acb9b0b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
@@ -58,11 +58,12 @@
     ClassSubject configClassSubject = inspector.clazz(Config.class);
     assertThat(configClassSubject, isPresent());
 
-    FieldSubject alwaysTrueFieldSubject = configClassSubject.uniqueFieldWithName("alwaysTrue");
+    FieldSubject alwaysTrueFieldSubject =
+        configClassSubject.uniqueFieldWithOriginalName("alwaysTrue");
     assertThat(alwaysTrueFieldSubject, isAbsent());
 
     FieldSubject alwaysTrueNoSideEffectsFieldSubject =
-        configClassSubject.uniqueFieldWithName("alwaysTrueNoSideEffects");
+        configClassSubject.uniqueFieldWithOriginalName("alwaysTrueNoSideEffects");
     assertThat(alwaysTrueNoSideEffectsFieldSubject, not(isPresent()));
 
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
index b171525..7c521aa 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
@@ -57,11 +57,12 @@
     ClassSubject configClassSubject = inspector.clazz(Config.class);
     assertThat(configClassSubject, isPresent());
 
-    FieldSubject alwaysEmptyFieldSubject = configClassSubject.uniqueFieldWithName("alwaysEmpty");
+    FieldSubject alwaysEmptyFieldSubject =
+        configClassSubject.uniqueFieldWithOriginalName("alwaysEmpty");
     assertThat(alwaysEmptyFieldSubject, isPresent());
 
     FieldSubject alwaysNonEmptyFieldSubject =
-        configClassSubject.uniqueFieldWithName("alwaysNonEmpty");
+        configClassSubject.uniqueFieldWithOriginalName("alwaysNonEmpty");
     assertThat(alwaysNonEmptyFieldSubject, isPresent());
 
     MethodSubject mainMethodSubject = classSubject.mainMethod();
@@ -78,7 +79,7 @@
                         || name.equals(alwaysNonEmptyFieldSubject.getFinalName())
                         || name.equals("out")));
 
-    MethodSubject deadMethodSubject = classSubject.uniqueMethodWithName("dead");
+    MethodSubject deadMethodSubject = classSubject.uniqueMethodWithOriginalName("dead");
     assertThat(deadMethodSubject, not(isPresent()));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
index bef3707..8ae967b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
@@ -41,8 +41,11 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(R.font.class);
               assertThat(classSubject, isPresent());
-              assertThat(classSubject.uniqueFieldWithName("roboto_mono_bold"), not(isPresent()));
-              assertThat(classSubject.uniqueFieldWithName("roboto_mono_regular"), not(isPresent()));
+              assertThat(
+                  classSubject.uniqueFieldWithOriginalName("roboto_mono_bold"), not(isPresent()));
+              assertThat(
+                  classSubject.uniqueFieldWithOriginalName("roboto_mono_regular"),
+                  not(isPresent()));
             })
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutputLines("1", "2", "1", "2", "1");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
index af4af19..d44418c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
@@ -53,9 +53,11 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
     assertThat(
-        testClassSubject.uniqueMethodWithName("deadDueToFieldValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("deadDueToFieldValuePropagation"),
+        not(isPresent()));
     assertThat(
-        testClassSubject.uniqueMethodWithName("deadDueToReturnValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("deadDueToReturnValuePropagation"),
+        not(isPresent()));
 
     // Verify that there are no more conditional instructions.
     MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
index ae2b510..a73e55f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
@@ -53,9 +53,11 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
     assertThat(
-        testClassSubject.uniqueMethodWithName("deadDueToFieldValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("deadDueToFieldValuePropagation"),
+        not(isPresent()));
     assertThat(
-        testClassSubject.uniqueMethodWithName("deadDueToReturnValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("deadDueToReturnValuePropagation"),
+        not(isPresent()));
 
     // Verify that there are no more conditional instructions.
     MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
index 3eb649a..54a69c1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
@@ -48,8 +48,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
index b493f1d..5b50028 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
@@ -77,8 +77,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
index 97dd34c..6cbacd6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
@@ -52,7 +52,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     ClassSubject configClassSubject = inspector.clazz(Config.class);
     assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
index 0745620..752e0c6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
@@ -58,7 +58,7 @@
     // Verify that all instance-get instructions in testDefinitelyNotNull() has been removed by
     // member value propagation.
     MethodSubject testDefinitelyNotNullMethodSubject =
-        testClassSubject.uniqueMethodWithName("testDefinitelyNotNull");
+        testClassSubject.uniqueMethodWithOriginalName("testDefinitelyNotNull");
     assertThat(testDefinitelyNotNullMethodSubject, isPresent());
     assertTrue(
         testDefinitelyNotNullMethodSubject
@@ -72,7 +72,7 @@
     // Verify that all instance-get instructions in testMaybeNull() has been removed by member value
     // propagation.
     MethodSubject testMaybeNullMethodSubject =
-        testClassSubject.uniqueMethodWithName("testMaybeNull");
+        testClassSubject.uniqueMethodWithOriginalName("testMaybeNull");
     assertThat(testMaybeNullMethodSubject, isPresent());
     assertTrue(
         testMaybeNullMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
index 6c7cf37..2ef6259 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
@@ -61,7 +61,7 @@
     // Verify that the `greeting` field is still present.
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueFieldWithName("greeting"), isPresent());
+    assertThat(aClassSubject.uniqueFieldWithOriginalName("greeting"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
index fb3d7e4..2a2eb77 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
@@ -55,17 +55,17 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    FieldSubject fieldSubject = aClassSubject.uniqueFieldWithName("field");
+    FieldSubject fieldSubject = aClassSubject.uniqueFieldWithOriginalName("field");
     assertThat(fieldSubject, not(isPresent()));
 
-    FieldSubject clinitFieldSubject = aClassSubject.uniqueFieldWithName("$r8$clinit");
+    FieldSubject clinitFieldSubject = aClassSubject.uniqueFieldWithOriginalName("$r8$clinit");
     assertThat(clinitFieldSubject, isPresent());
 
     // B.method() is present.
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject methodSubject = bClassSubject.uniqueMethodWithName("method");
+    MethodSubject methodSubject = bClassSubject.uniqueMethodWithOriginalName("method");
     assertThat(methodSubject, not(isPresent()));
 
     // TestClass.missingFieldValuePropagation() and TestClass.missingMethodValuePropagation() are
@@ -73,9 +73,11 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
     assertThat(
-        testClassSubject.uniqueMethodWithName("missingFieldValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("missingFieldValuePropagation"),
+        not(isPresent()));
     assertThat(
-        testClassSubject.uniqueMethodWithName("missingMethodValuePropagation"), not(isPresent()));
+        testClassSubject.uniqueMethodWithOriginalName("missingMethodValuePropagation"),
+        not(isPresent()));
 
     // TestClass.main() still accesses A.field and invokes B.method().
     MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
index 52a163e..a00178c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
@@ -48,19 +48,19 @@
               assertThat(fontClassSubject, isPresent());
 
               FieldSubject robotoMonoFieldSubject =
-                  fontClassSubject.uniqueFieldWithName("roboto_mono");
+                  fontClassSubject.uniqueFieldWithOriginalName("roboto_mono");
               assertThat(robotoMonoFieldSubject, not(isPresent()));
 
               FieldSubject robotoMonoBoldFieldSubject =
-                  fontClassSubject.uniqueFieldWithName("roboto_mono_bold");
+                  fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_bold");
               assertThat(robotoMonoBoldFieldSubject, not(isPresent()));
 
               FieldSubject robotoMonoRegularFieldSubject =
-                  fontClassSubject.uniqueFieldWithName("roboto_mono_regular");
+                  fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_regular");
               assertThat(robotoMonoRegularFieldSubject, not(isPresent()));
 
               FieldSubject robotoMonoWeightsFieldSubject =
-                  fontClassSubject.uniqueFieldWithName("roboto_mono_weights");
+                  fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_weights");
               assertThat(robotoMonoWeightsFieldSubject, isPresent());
 
               ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
index 433ee13..611bf52 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
@@ -54,7 +54,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     ClassSubject configClassSubject = inspector.clazz(Config.class);
     assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
index c69ddd6..e9fd562 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
@@ -54,7 +54,7 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
     // TODO(b/147799637): Should be absent.
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), isPresent());
 
     ClassSubject configClassSubject = inspector.clazz(Config.class);
     assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
index fba6f58..1aa4d4b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
index b6fe557..2de70ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
index 97b57f4..e9a9f9e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), isAbsent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
index ca34efd..d0698d2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
index 0902756..3710a80 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
index c3a453d..8eced2c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
index c89cfa9..cc6c98c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
@@ -51,8 +51,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
index 9ffd5ee..8634896 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
@@ -52,8 +52,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
index c515e70..d0e1260 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
index 3033e29..1dba47d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
index bf1ec2e..5e553e4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
@@ -47,7 +47,7 @@
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
 
-              FieldSubject fieldSubject = mainClassSubject.uniqueFieldWithName("f");
+              FieldSubject fieldSubject = mainClassSubject.uniqueFieldWithOriginalName("f");
               assertEquals(
                   aClassSubject.getFinalName(), fieldSubject.getField().getType().getTypeName());
             })
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
index 4c19863..eec914f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
@@ -49,9 +49,9 @@
   private void verifyNonNullPropagation(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
-    assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
index a6f8740..557be25 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
@@ -52,8 +52,8 @@
 
   private void inspect(CodeInspector inspector) {
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
index baf0868..8418f9c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
@@ -66,7 +66,7 @@
   private void inspect(CodeInspector inspector) {
     if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
       ClassSubject interfaceSubject = inspector.clazz(I.class);
-      MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+      MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithOriginalName("greet");
       assertThat(interfaceSubject, isPresent());
       assertThat(greetMethodSubject, isPresent());
       assertEquals(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
index e1763f1..2bbb1b6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
@@ -68,7 +68,7 @@
             : inspector.clazz(I.class.getTypeName() + getCompanionClassNameSuffix());
     assertThat(interfaceSubject, isPresent());
 
-    MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+    MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithOriginalName("greet");
     assertThat(greetMethodSubject, isPresent());
     assertEquals(
         1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
index 696a413..69b56ce 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
@@ -88,24 +88,24 @@
     ClassSubject outlineClass =
         inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(main, 0));
     MethodSubject outlineMethod =
-        outlineClass.uniqueMethodWithName(SyntheticItemsTestUtils.syntheticMethodName());
+        outlineClass.uniqueMethodWithOriginalName(SyntheticItemsTestUtils.syntheticMethodName());
     assertThat(outlineMethod, isPresent());
 
     ClassSubject argClass = inspector.clazz(TestArg.class);
     assertThat(argClass, isPresent());
-    MethodSubject printHash = argClass.uniqueMethodWithName("printHash");
+    MethodSubject printHash = argClass.uniqueMethodWithOriginalName("printHash");
     assertThat(printHash, isPresent());
-    MethodSubject printArg= argClass.uniqueMethodWithName("printArg");
+    MethodSubject printArg = argClass.uniqueMethodWithOriginalName("printArg");
     assertThat(printArg, isPresent());
 
     ClassSubject classSubject = inspector.clazz(main);
     assertThat(classSubject, isPresent());
-    MethodSubject method1 = classSubject.uniqueMethodWithName("method1");
+    MethodSubject method1 = classSubject.uniqueMethodWithOriginalName("method1");
     assertThat(method1, isPresent());
     assertThat(method1, CodeMatchers.invokesMethod(outlineMethod));
     assertThat(method1, not(CodeMatchers.invokesMethod(printHash)));
     assertThat(method1, not(CodeMatchers.invokesMethod(printArg)));
-    MethodSubject method2 = classSubject.uniqueMethodWithName("method2");
+    MethodSubject method2 = classSubject.uniqueMethodWithOriginalName("method2");
     assertThat(method2, isPresent());
     assertThat(method2, CodeMatchers.invokesMethod(outlineMethod));
     assertThat(method2, not(CodeMatchers.invokesMethod(printHash)));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
index 63aed12..7325c71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
@@ -48,9 +48,11 @@
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(
-        classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method1"),
+        CodeMatchers.invokesMethod(outline0Method));
     assertThat(
-        classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method2"),
+        CodeMatchers.invokesMethod(outline0Method));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
index 4f6a822..7b7c6c3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
@@ -57,9 +57,11 @@
       assertThat(outline0Method, isPresent());
       ClassSubject classSubject = inspector.clazz(TestClass.class);
       assertThat(
-          classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+          classSubject.uniqueMethodWithOriginalName("method1"),
+          CodeMatchers.invokesMethod(outline0Method));
       assertThat(
-          classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+          classSubject.uniqueMethodWithOriginalName("method2"),
+          CodeMatchers.invokesMethod(outline0Method));
     } else {
       assertThat(outlineClass, not(isPresent()));
     }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
index 2065f83..3939dd0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
@@ -47,9 +47,11 @@
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(
-        classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method1"),
+        CodeMatchers.invokesMethod(outline0Method));
     assertThat(
-        classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method2"),
+        CodeMatchers.invokesMethod(outline0Method));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
index ee81c79..fcada92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
@@ -51,10 +51,10 @@
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(
-        classSubject.uniqueMethodWithName("ifaceMethod"),
+        classSubject.uniqueMethodWithOriginalName("ifaceMethod"),
         CodeMatchers.invokesMethod(outline0Method));
     assertThat(
-        classSubject.uniqueMethodWithName("methodWithOutlineContent"),
+        classSubject.uniqueMethodWithOriginalName("methodWithOutlineContent"),
         CodeMatchers.invokesMethod(outline0Method));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
index 0d1f637..ee43078 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
@@ -108,10 +108,14 @@
 
     // Verify they are called from the feature methods.
     // Note: should the choice of synthetic grouping change these expectations will too.
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
-    assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
+    assertTrue(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method1"), outlineClassName));
+    assertTrue(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method2"), outlineClassName));
+    assertTrue(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method3"), outlineClassName));
+    assertTrue(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method4"), outlineClassName));
 
     compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("123456");
   }
@@ -160,10 +164,14 @@
             .inverse
             .get(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0).getTypeName());
 
-    assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
-    assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
-    assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
-    assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
+    assertFalse(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method1"), outlineClassName));
+    assertFalse(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method2"), outlineClassName));
+    assertFalse(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method3"), outlineClassName));
+    assertFalse(
+        invokesOutline(featureClass.uniqueMethodWithOriginalName("method4"), outlineClassName));
 
     // Run the code without the feature code present.
     compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("12");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
index 9437d1d..29690ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
@@ -54,9 +54,11 @@
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(
-        classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method1"),
+        CodeMatchers.invokesMethod(outline0Method));
     assertThat(
-        classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method2"),
+        CodeMatchers.invokesMethod(outline0Method));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
index 8385328..81f4c01 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
@@ -62,9 +62,11 @@
     assertThat(outline0Method, isPresent());
     ClassSubject classSubject = inspector.clazz(testClass);
     assertThat(
-        classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method1"),
+        CodeMatchers.invokesMethod(outline0Method));
     assertThat(
-        classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+        classSubject.uniqueMethodWithOriginalName("method2"),
+        CodeMatchers.invokesMethod(outline0Method));
   }
 
   public void runTest(Class<?> testClass, String argumentType, String expectedOutput)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
index b5c1de5..95b0a58 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
@@ -61,15 +61,23 @@
 
   private void inspect(CodeInspector inspector) {
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
-    assertArrayGetCountEquals(1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGet"));
     assertArrayGetCountEquals(
-        1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGetAfterPutToUnrelatedArray"));
+        1, mainClassSubject.uniqueMethodWithOriginalName("testRedundantArrayGet"));
     assertArrayGetCountEquals(
-        1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGetAfterPutToUnrelatedIndex"));
+        1,
+        mainClassSubject.uniqueMethodWithOriginalName(
+            "testRedundantArrayGetAfterPutToUnrelatedArray"));
     assertArrayGetCountEquals(
-        2, mainClassSubject.uniqueMethodWithName("testNecessaryArrayGetAfterAliasedArrayPut"));
+        1,
+        mainClassSubject.uniqueMethodWithOriginalName(
+            "testRedundantArrayGetAfterPutToUnrelatedIndex"));
     assertArrayGetCountEquals(
-        2, mainClassSubject.uniqueMethodWithName("testNecessaryArrayGetAfterExternalSideEffect"));
+        2,
+        mainClassSubject.uniqueMethodWithOriginalName("testNecessaryArrayGetAfterAliasedArrayPut"));
+    assertArrayGetCountEquals(
+        2,
+        mainClassSubject.uniqueMethodWithOriginalName(
+            "testNecessaryArrayGetAfterExternalSideEffect"));
   }
 
   static void assertArrayGetCountEquals(int expected, MethodSubject methodSubject) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
index af7854c..6ea3dcf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
@@ -59,7 +59,7 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithName("f");
+    FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithOriginalName("f");
     assertThat(fFieldSubject, isPresent());
 
     MethodSubject initMethodSubject = aClassSubject.init();
@@ -69,7 +69,7 @@
         countInstanceGetInstructions(
             initMethodSubject.asFoundMethodSubject(), fFieldSubject.asFoundFieldSubject()));
 
-    MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithName("m");
+    MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
     assertThat(mMethodSubject, isPresent());
     assertEquals(
         2,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
index 701c43f..1bbe682 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
@@ -53,7 +53,7 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithName("f");
+    FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithOriginalName("f");
     assertThat(fFieldSubject, isPresent());
 
     MethodSubject initMethodSubject = aClassSubject.clinit();
@@ -63,7 +63,7 @@
         countStaticGetInstructions(
             initMethodSubject.asFoundMethodSubject(), fFieldSubject.asFoundFieldSubject()));
 
-    MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithName("m");
+    MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
     assertThat(mMethodSubject, isPresent());
     assertEquals(
         1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
index d7e4296..99a6045 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
@@ -43,8 +43,8 @@
             inspector -> {
               ClassSubject greeterClassSubject = inspector.clazz(Greeter.class);
               assertThat(greeterClassSubject, isPresent());
-              assertThat(greeterClassSubject.uniqueMethodWithName("hello"), isAbsent());
-              assertThat(greeterClassSubject.uniqueMethodWithName("world"), isPresent());
+              assertThat(greeterClassSubject.uniqueMethodWithOriginalName("hello"), isAbsent());
+              assertThat(greeterClassSubject.uniqueMethodWithOriginalName("world"), isPresent());
               assertEquals(0, greeterClassSubject.allFields().size());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
index 73e21ba..25987d2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
@@ -45,7 +45,7 @@
               ClassSubject classSubject = inspector.clazz(TestClass.class);
               assertThat(classSubject, isPresent());
 
-              FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+              FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
               assertThat(fieldSubject, isAbsent());
             })
         .run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
index 936b777..0ea210f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
@@ -46,7 +46,7 @@
               ClassSubject classSubject = inspector.clazz(TestClass.class);
               assertThat(classSubject, isPresent());
 
-              FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+              FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
               assertThat(fieldSubject, isAbsent());
 
               MethodSubject methodSubject = classSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
index 908ce00..a50261b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
@@ -170,10 +170,11 @@
     ClassSubject reflectionClass = codeInspector.clazz(Reflection.class);
     assertThat(reflectionClass, isPresent());
     assertThat(
-        reflectionClass.uniqueMethodWithName("call"), onlyIf(expectCallPresent, isPresent()));
+        reflectionClass.uniqueMethodWithOriginalName("call"),
+        onlyIf(expectCallPresent, isPresent()));
 
     ClassSubject getterClass = codeInspector.clazz(GetClassTestMain.class);
-    MethodSubject getMainClass = getterClass.uniqueMethodWithName("getMainClass");
+    MethodSubject getMainClass = getterClass.uniqueMethodWithOriginalName("getMainClass");
     assertThat(getMainClass, isPresent());
     // Because of nullable argument, getClass() should remain.
     assertEquals(1, countGetClass(getMainClass));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
index a6d3931..581caa9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
@@ -169,7 +169,7 @@
     if (isOptimizing) {
       ClassSubject testHelperClassSubject = codeInspector.clazz(TestHelper.class);
       assertThat(testHelperClassSubject, isPresent());
-      assertThat(testHelperClassSubject.uniqueMethodWithName("getClassName"), isAbsent());
+      assertThat(testHelperClassSubject.uniqueMethodWithOriginalName("getClassName"), isAbsent());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
index 66ae08d..813fdfc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
@@ -51,19 +51,19 @@
         .setMinApi(parameters.getApiLevel())
         .addFeatureSplit(
             builder ->
-                SplitterTestBase.simpleSplitProvider(
-                    builder, featurePath, temp, Foobar.class))
+                SplitterTestBase.simpleSplitProvider(builder, featurePath, temp, Foobar.class))
         .addKeepMainRule(Main.class)
         .addKeepClassRules(Foobar.class)
         .enableInliningAnnotations()
         .compile()
-        .inspect(codeInspector -> {
-          ClassSubject mainClass = codeInspector.clazz(Main.class);
-          MethodSubject foo = mainClass.uniqueMethodWithName("foo");
-          assertThat(foo, isPresent());
-          // Make sure Class#forName is indeed kept.
-          assertEquals(1, countForName(foo));
-        })
+        .inspect(
+            codeInspector -> {
+              ClassSubject mainClass = codeInspector.clazz(Main.class);
+              MethodSubject foo = mainClass.uniqueMethodWithOriginalName("foo");
+              assertThat(foo, isPresent());
+              // Make sure Class#forName is indeed kept.
+              assertEquals(1, countForName(foo));
+            })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines(EXPECTED);
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
index 4032c83..9cf458d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
@@ -422,13 +422,13 @@
     ClassSubject clazz = inspector.clazz(main);
 
     // Check that "calledTwice" is removed (inlined into main).
-    assertThat(clazz.uniqueMethodWithName("calledTwice"), not(isPresent()));
+    assertThat(clazz.uniqueMethodWithOriginalName("calledTwice"), not(isPresent()));
 
     // Check that the two inlines of "calledTwice" is correctly rewritten.
     ClassSubject candidateClassSubject = inspector.clazz(Candidate.class);
     assertThat(candidateClassSubject, isPresent());
-    assertThat(candidateClassSubject.uniqueMethodWithName("foo"), isPresent());
-    assertThat(candidateClassSubject.uniqueMethodWithName("bar"), isPresent());
+    assertThat(candidateClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+    assertThat(candidateClassSubject.uniqueMethodWithOriginalName("bar"), isPresent());
     assertEquals(
         Lists.newArrayList(
             "STATIC: String dualcallinline.Candidate.foo()",
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
index be47557..bb1849e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
@@ -53,7 +53,7 @@
     // Check if the candidate is not staticized.
     ClassSubject companion = inspector.clazz(Host.Companion.class);
     assertThat(companion, isPresent());
-    MethodSubject foo = companion.uniqueMethodWithName("foo");
+    MethodSubject foo = companion.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     assertTrue(
         foo.streamInstructions().anyMatch(
@@ -63,7 +63,7 @@
     // Nothing migrated from Companion to Host.
     ClassSubject host = inspector.clazz(Host.class);
     assertThat(host, isPresent());
-    MethodSubject migrated_foo = host.uniqueMethodWithName("foo");
+    MethodSubject migrated_foo = host.uniqueMethodWithOriginalName("foo");
     assertThat(migrated_foo, not(isPresent()));
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
index 76bee19..1e89087 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
@@ -51,7 +51,8 @@
     ClassSubject companionClassSubject = inspector.clazz(Companion.class);
     assertThat(companionClassSubject, isPresent());
 
-    MethodSubject companionMethodSubject = companionClassSubject.uniqueMethodWithName("method");
+    MethodSubject companionMethodSubject =
+        companionClassSubject.uniqueMethodWithOriginalName("method");
     assertThat(companionMethodSubject, isPresent());
     assertThat(companionMethodSubject, isStatic());
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
index 5dabfaf..1c1c5b5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
@@ -55,14 +55,14 @@
     // Check if the instance is gone.
     ClassSubject host = inspector.clazz(Candidate.Host.class);
     assertThat(host, isPresent());
-    FieldSubject instance = host.uniqueFieldWithName("INSTANCE");
+    FieldSubject instance = host.uniqueFieldWithOriginalName("INSTANCE");
     assertThat(instance, not(isPresent()));
 
     ClassSubject candidate = inspector.clazz(Candidate.class);
     assertThat(candidate, not(isPresent()));
 
     // Check if the candidate method is staticized and migrated.
-    MethodSubject foo = host.uniqueMethodWithName("foo");
+    MethodSubject foo = host.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     assertTrue(foo.isStatic());
     assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
index 9dfcb42..06397fc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
@@ -61,7 +61,7 @@
     // Check if the instance is gone.
     ClassSubject host = inspector.clazz(Host.class);
     assertThat(host, isPresent());
-    FieldSubject instance = host.uniqueFieldWithName("companion");
+    FieldSubject instance = host.uniqueFieldWithOriginalName("companion");
     assertThat(instance, not(isPresent()));
 
     ClassSubject companion = inspector.clazz(Host.Companion.class);
@@ -71,7 +71,7 @@
     // Check if the candidate methods are staticized (if necessary) and migrated.
     for (String name : ImmutableList.of("boo", "foo")) {
       // TODO(b/158018192): This should be host and not companion.
-      MethodSubject oo = companion.uniqueMethodWithName(name);
+      MethodSubject oo = companion.uniqueMethodWithOriginalName(name);
       assertThat(oo, isPresent());
       assertTrue(oo.isStatic());
       assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
index f49ca5e..b58fdd7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
@@ -125,7 +125,7 @@
       assertEquals(expectedConstNumberCountInClinit, countNonZeroConstNumber(clinit));
     }
 
-    MethodSubject m = mainClass.uniqueMethodWithName("instanceMethod");
+    MethodSubject m = mainClass.uniqueMethodWithOriginalName("instanceMethod");
     assertThat(m, isPresent());
     assertEquals(expectedStringLengthCountInInstanceMethod, countStringLength(m));
     assertEquals(expectedConstNumberCountInInstanceMethod, countNonZeroConstNumber(m));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
index 277e1e3..c015182 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
@@ -102,7 +102,7 @@
     CodeInspector codeInspector = result.inspector();
     ClassSubject mainClass = codeInspector.clazz(MAIN);
 
-    MethodSubject method = mainClass.uniqueMethodWithName("unusedBuilder");
+    MethodSubject method = mainClass.uniqueMethodWithOriginalName("unusedBuilder");
     if (isR8) {
       assertThat(method, not(isPresent()));
     } else {
@@ -110,80 +110,80 @@
       assertEquals(0, countConstString(method));
     }
 
-    method = mainClass.uniqueMethodWithName("trivialSequence");
+    method = mainClass.uniqueMethodWithOriginalName("trivialSequence");
     assertThat(method, isPresent());
     expectedCount = isReleaseMode ? 1 : 3;
     assertEquals(expectedCount, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("builderWithInitialValue");
+    method = mainClass.uniqueMethodWithOriginalName("builderWithInitialValue");
     assertThat(method, isPresent());
     expectedCount = isReleaseMode ? 1 : 3;
     assertEquals(expectedCount, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("builderWithCapacity");
+    method = mainClass.uniqueMethodWithOriginalName("builderWithCapacity");
     assertThat(method, isPresent());
     expectedCount = isReleaseMode ? 1 : 0;
     assertEquals(expectedCount, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("nonStringArgs");
+    method = mainClass.uniqueMethodWithOriginalName("nonStringArgs");
     assertThat(method, isPresent());
     expectedCount = isReleaseMode ? 1 : 0;
     assertEquals(expectedCount, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("typeConversion");
+    method = mainClass.uniqueMethodWithOriginalName("typeConversion");
     assertThat(method, isPresent());
     expectedCount = isReleaseMode ? 1 : 0;
     assertEquals(expectedCount, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("typeConversion_withPhis");
+    method = mainClass.uniqueMethodWithOriginalName("typeConversion_withPhis");
     assertThat(method, isPresent());
     assertEquals(0, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("nestedBuilders_appendBuilderItself");
+    method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_appendBuilderItself");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 1 : 3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("nestedBuilders_appendBuilderResult");
+    method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_appendBuilderResult");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 1 : 3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("nestedBuilders_conditional");
+    method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_conditional");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 3 : 4, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("concatenatedBuilders_init");
+    method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_init");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 1 : 2, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("concatenatedBuilders_append");
+    method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_append");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 1 : 2, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("concatenatedBuilders_conditional");
+    method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_conditional");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 2 : 4, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("simplePhi");
+    method = mainClass.uniqueMethodWithOriginalName("simplePhi");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 3 : 4, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("phiAtInit");
+    method = mainClass.uniqueMethodWithOriginalName("phiAtInit");
     assertThat(method, isPresent());
     assertEquals(3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("phiWithDifferentInits");
+    method = mainClass.uniqueMethodWithOriginalName("phiWithDifferentInits");
     assertThat(method, isPresent());
     assertEquals(3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("conditionalPhiWithoutAppend");
+    method = mainClass.uniqueMethodWithOriginalName("conditionalPhiWithoutAppend");
     assertThat(method, isPresent());
     assertEquals(isReleaseMode ? 2 : 3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("loop");
+    method = mainClass.uniqueMethodWithOriginalName("loop");
     assertThat(method, isPresent());
     assertEquals(3, countConstString(method));
 
-    method = mainClass.uniqueMethodWithName("loopWithBuilder");
+    method = mainClass.uniqueMethodWithOriginalName("loopWithBuilder");
     assertThat(method, isPresent());
     assertEquals(2, countConstString(method));
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
index 1f7b97d..04b57b2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
@@ -147,7 +147,7 @@
     long count = countStringContentChecker(mainMethod);
     assertEquals(expectedStringContentCheckerCount, count);
 
-    MethodSubject argCouldBeNull = mainClass.uniqueMethodWithName("argCouldBeNull");
+    MethodSubject argCouldBeNull = mainClass.uniqueMethodWithOriginalName("argCouldBeNull");
     assertThat(argCouldBeNull, isPresent());
     // Because of nullable argument, all checkers should remain.
     assertEquals(10, countStringContentChecker(argCouldBeNull));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
index 6c47b03..381797b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
@@ -67,7 +67,7 @@
     assertThat(mainMethod, isPresent());
     assertEquals(expectedStringIsEmptyCount, countCall(mainMethod, "String", "isEmpty"));
 
-    MethodSubject wrapper = mainClass.uniqueMethodWithName("wrapper");
+    MethodSubject wrapper = mainClass.uniqueMethodWithOriginalName("wrapper");
     assertThat(wrapper, isPresent());
     // Due to nullable, non-constant argument (w/o call-site optimization), isEmpty() should remain.
     assertEquals(1, countCall(wrapper, "String", "isEmpty"));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
index dba68cd..a302652 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
@@ -91,11 +91,11 @@
     expectedCount = isR8 ? (parameters.isCfRuntime() ? 2 : 1) : (isRelease ? 1 : 0);
     assertEquals(expectedCount, countNullStringNumber(mainMethod));
 
-    MethodSubject hideNPE = mainClass.uniqueMethodWithName("hideNPE");
+    MethodSubject hideNPE = mainClass.uniqueMethodWithOriginalName("hideNPE");
     // Due to the nullable argument, valueOf should remain.
     assertEquals(1, countCall(hideNPE, "String", "valueOf"));
 
-    MethodSubject uninit = mainClass.uniqueMethodWithName("consumeUninitialized");
+    MethodSubject uninit = mainClass.uniqueMethodWithOriginalName("consumeUninitialized");
     assertThat(uninit, isPresent());
     expectedCount = isR8 ? 0 : 1;
     assertEquals(expectedCount, countCall(uninit, "String", "valueOf"));
@@ -120,7 +120,7 @@
                 inspector -> {
                   ClassSubject fooClassSubject = inspector.clazz(Foo.class);
                   assertThat(fooClassSubject, isPresent());
-                  assertThat(fooClassSubject.uniqueMethodWithName("getter"), isAbsent());
+                  assertThat(fooClassSubject.uniqueMethodWithOriginalName("getter"), isAbsent());
                 })
             .run(parameters.getRuntime(), MAIN)
             .assertSuccessWithOutput(JAVA_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
index 213f02b..11a1e35 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
@@ -64,7 +64,8 @@
   }
 
   private void verifyRewrittenToIfs(CodeInspector inspector) {
-    MethodSubject testMethodSubject = inspector.clazz(Main.class).uniqueMethodWithName("test");
+    MethodSubject testMethodSubject =
+        inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
     assertThat(testMethodSubject, isPresent());
     assertTrue(testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
     assertEquals(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
index 86e30dc..a5eddd4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
@@ -69,10 +69,11 @@
   private void verifyOutput(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     {
-      MethodSubject methodSubject = classSubject.uniqueMethodWithName("testSwitchCaseRemoval");
+      MethodSubject methodSubject =
+          classSubject.uniqueMethodWithOriginalName("testSwitchCaseRemoval");
       assertThat(methodSubject, isPresent());
       assertEquals(
           1, methodSubject.streamInstructions().filter(InstructionSubject::isConstNull).count());
@@ -83,14 +84,15 @@
 
     {
       MethodSubject methodSubject =
-          classSubject.uniqueMethodWithName("testSwitchReplacementWithExplicitDefaultCase");
+          classSubject.uniqueMethodWithOriginalName("testSwitchReplacementWithExplicitDefaultCase");
       assertThat(methodSubject, isPresent());
       assertTrue(methodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
     }
 
     {
       MethodSubject methodSubject =
-          classSubject.uniqueMethodWithName("testSwitchReplacementWithoutExplicitDefaultCase");
+          classSubject.uniqueMethodWithOriginalName(
+              "testSwitchReplacementWithoutExplicitDefaultCase");
       assertThat(methodSubject, isPresent());
       assertTrue(methodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
     }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
index ed970af..f258093 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
@@ -65,27 +65,27 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
-    assertThat(aClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
-    assertThat(aClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
-    assertThat(aClassSubject.uniqueMethodWithName("isSuper"), isPresent());
-    assertThat(aClassSubject.uniqueMethodWithName("isSub"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("isSuper"), isPresent());
+    assertThat(aClassSubject.uniqueMethodWithOriginalName("isSub"), isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("isSuper"), not(isPresent()));
-    assertThat(bClassSubject.uniqueMethodWithName("isSub"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("isSuper"), not(isPresent()));
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("isSub"), not(isPresent()));
 
     ClassSubject cClassSubject = inspector.clazz(C.class);
     assertThat(cClassSubject, isPresent());
-    assertThat(cClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
-    assertThat(cClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
-    assertThat(cClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
-    assertThat(cClassSubject.uniqueMethodWithName("isSuper"), isPresent());
-    assertThat(cClassSubject.uniqueMethodWithName("isSub"), isPresent());
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("isSuper"), isPresent());
+    assertThat(cClassSubject.uniqueMethodWithOriginalName("isSub"), isPresent());
   }
 
   public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
index c12a128..80d38dc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
@@ -132,8 +132,8 @@
     assertEquals(12, found);
 
     // Check that the method live() has been kept and that dead() has been removed.
-    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     // Check that the catch handlers for NullPointerException and RuntimeException have not been
     // removed.
@@ -144,7 +144,7 @@
             "handleRuntimeExceptionForInvokeStatic",
             "handleRuntimeExceptionForInvokeVirtual");
     for (String methodName : methodNames) {
-      assertThat(testClassSubject.uniqueMethodWithName(methodName), isPresent());
+      assertThat(testClassSubject.uniqueMethodWithOriginalName(methodName), isPresent());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
index 55889a3..6457961 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
@@ -81,7 +81,7 @@
     assertNotEquals(enableArgumentPropagation, otherClassSubject.isPresent());
 
     // Check that A.method() has been removed.
-    assertThat(otherClassSubject.uniqueMethodWithName("method"), not(isPresent()));
+    assertThat(otherClassSubject.uniqueMethodWithOriginalName("method"), not(isPresent()));
 
     // Check that a throw instruction has been inserted into each of the testRewriteToThrowNull*
     // methods.
@@ -97,12 +97,14 @@
     assertEquals(3, found);
 
     // Check that the method dead() has been removed.
-    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+    assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
 
     // Check that the catch handlers for NullPointerException and RuntimeException have not been
     // removed.
-    assertThat(testClassSubject.uniqueMethodWithName("handleNullPointerException"), isPresent());
-    assertThat(testClassSubject.uniqueMethodWithName("handleRuntimeException"), isPresent());
+    assertThat(
+        testClassSubject.uniqueMethodWithOriginalName("handleNullPointerException"), isPresent());
+    assertThat(
+        testClassSubject.uniqueMethodWithOriginalName("handleRuntimeException"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
index 4d032c7..4119731 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
@@ -62,7 +62,7 @@
     assertThat(classSubject, isPresent());
 
     // Check that the method live() has not been removed.
-    assertThat(classSubject.uniqueMethodWithName("live"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("live"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
index 17d3ccc..032b058 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
@@ -64,14 +64,14 @@
 
     ClassSubject factoryClassSubject = inspector.clazz(Factory.class);
     MethodSubject createStaticMethodSubject =
-        factoryClassSubject.uniqueMethodWithName("createStatic");
+        factoryClassSubject.uniqueMethodWithOriginalName("createStatic");
     assertThat(createStaticMethodSubject, isPresent());
     assertEquals(1, createStaticMethodSubject.getMethod().getParameters().size());
 
     for (int i = 1; i <= 3; ++i) {
       String createStaticWithUnusedMethodName = "createStaticWithUnused" + i;
       MethodSubject createStaticWithUnusedMethodSubject =
-          factoryClassSubject.uniqueMethodWithName(createStaticWithUnusedMethodName);
+          factoryClassSubject.uniqueMethodWithOriginalName(createStaticWithUnusedMethodName);
       assertThat(createStaticWithUnusedMethodSubject, isPresent());
 
       DexMethod method = createStaticWithUnusedMethodSubject.getMethod().getReference();
@@ -80,7 +80,7 @@
     }
 
     MethodSubject createStaticWithUnusedMethodSubject =
-        factoryClassSubject.uniqueMethodWithName("createStaticWithUnused4");
+        factoryClassSubject.uniqueMethodWithOriginalName("createStaticWithUnused4");
     assertThat(createStaticWithUnusedMethodSubject, isPresent());
 
     DexMethod method = createStaticWithUnusedMethodSubject.getMethod().getReference();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
index a04df37..99d3ae2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
@@ -57,7 +57,7 @@
             .inspector();
 
     ClassSubject clazz = inspector.clazz(A.class);
-    MethodSubject method = clazz.uniqueMethodWithName("m");
+    MethodSubject method = clazz.uniqueMethodWithOriginalName("m");
     assertThat(method, isPresent());
 
     // The invoke on the uninstantiated turns into a "throw null", and the synchronized method
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
index 65132d2..e46ce92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
@@ -92,12 +92,12 @@
 
     List<MethodSubject> methodSubjects =
         ImmutableList.of(
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromStart"),
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromMiddle"),
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromEnd"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromStart"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromMiddle"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromEnd"));
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromStart"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromMiddle"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromEnd"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromStart"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromMiddle"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromEnd"));
 
     for (MethodSubject methodSubject : methodSubjects) {
       assertThat(methodSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
index 831330d..0665133 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
@@ -69,16 +69,16 @@
 
     ClassSubject factoryClassSubject = inspector.clazz(Factory.class);
     MethodSubject createStaticMethodSubject =
-        factoryClassSubject.uniqueMethodWithName("createStatic");
+        factoryClassSubject.uniqueMethodWithOriginalName("createStatic");
     assertThat(createStaticMethodSubject, isPresent());
     assertTrue(createStaticMethodSubject.getMethod().getReturnType().isVoidType());
     MethodSubject createVirtualMethodSubject =
-        factoryClassSubject.uniqueMethodWithName("createVirtual");
+        factoryClassSubject.uniqueMethodWithOriginalName("createVirtual");
     assertThat(createVirtualMethodSubject, isPresent());
     assertTrue(createVirtualMethodSubject.getMethod().getReturnType().isVoidType());
 
     createVirtualMethodSubject =
-        inspector.clazz(SubFactory.class).uniqueMethodWithName("createVirtual");
+        inspector.clazz(SubFactory.class).uniqueMethodWithOriginalName("createVirtual");
     assertThat(createVirtualMethodSubject, isPresent());
     assertTrue(createVirtualMethodSubject.getMethod().getReturnType().isVoidType());
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
index 0f5b122..9b355fe 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
@@ -49,7 +49,7 @@
             inspector -> {
               ClassSubject aClassSubject = inspector.clazz(A.class);
 
-              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertEquals(1, fooMethodSubject.getProgramMethod().getParameters().size());
               assertEquals(
@@ -57,7 +57,7 @@
                   fooMethodSubject.getProgramMethod().getParameter(0));
               assertThat(fooMethodSubject, invokesMethodWithName("getClass"));
 
-              MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+              MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
               assertThat(barMethodSubject, isStatic());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
index 2f3e14f..fd8e3ac 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
@@ -90,12 +90,12 @@
 
     List<MethodSubject> methodSubjects =
         ImmutableList.of(
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromStart"),
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromMiddle"),
-            testClassSubject.uniqueMethodWithName("testRemoveStaticFromEnd"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromStart"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromMiddle"),
-            testClassSubject.uniqueMethodWithName("testRemoveVirtualFromEnd"));
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromStart"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromMiddle"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromEnd"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromStart"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromMiddle"),
+            testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromEnd"));
 
     for (MethodSubject methodSubject : methodSubjects) {
       assertThat(methodSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
index 44c15e6..d595562 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
@@ -62,7 +62,7 @@
     ClassSubject classSubject = inspector.clazz(B.class);
     assertThat(classSubject, isPresent());
 
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName("greeting");
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("greeting");
     assertThat(methodSubject, isPresent());
     assertEquals(
         "java.lang.String", methodSubject.getMethod().getReference().proto.parameters.toString());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
index 7527598..1c59e0f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
@@ -74,10 +74,10 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    MethodSubject methodA1Subject = aClassSubject.uniqueMethodWithName("method1");
+    MethodSubject methodA1Subject = aClassSubject.uniqueMethodWithOriginalName("method1");
     assertThat(methodA1Subject, isPresent());
 
-    MethodSubject methodA2Subject = aClassSubject.uniqueMethodWithName("method2");
+    MethodSubject methodA2Subject = aClassSubject.uniqueMethodWithOriginalName("method2");
     assertThat(methodA2Subject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
index a4622bc..3f23ccc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
@@ -67,7 +67,7 @@
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject, isPresent());
 
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName("<init>");
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("<init>");
     assertThat(methodSubject, isPresent());
     assertTrue(methodSubject.getMethod().getReference().proto.parameters.isEmpty());
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
index 175b2cb..6b9cb0a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
@@ -44,7 +44,8 @@
               ClassSubject mainClassSubject = inspector.clazz(Main.class);
               assertThat(mainClassSubject, isPresent());
 
-              MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isStatic());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java b/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
index 8add503..3503deb 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
@@ -46,7 +46,7 @@
               ClassSubject c = inspector.clazz(TestClass.class);
               assertThat(c, isPresent());
 
-              MethodSubject m = c.uniqueMethodWithName("invokeRangeTest");
+              MethodSubject m = c.uniqueMethodWithOriginalName("invokeRangeTest");
               assertThat(m, isPresent());
               Iterator<InstructionSubject> it =
                   m.iterateInstructions(InstructionSubject::isConstNumber);
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index 5cdae5d..253d335 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -150,7 +150,7 @@
   }
 
   protected FieldSubject checkFieldIsKept(ClassSubject classSubject, String fieldName) {
-    FieldSubject fieldSubject = classSubject.uniqueFieldWithName(fieldName);
+    FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName(fieldName);
     assertThat(fieldSubject, isPresent());
     return fieldSubject;
   }
@@ -175,7 +175,7 @@
   }
 
   protected MethodSubject checkMethodIsKept(ClassSubject classSubject, String methodName) {
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
     assertThat(methodSubject, isPresent());
     return methodSubject;
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
index a664d59..b0f4980 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -74,7 +74,7 @@
 
               // Note that isSupported itself has a parameter whose null check would be inlined
               // with -allowaccessmodification.
-              MethodSubject isSupported = main.uniqueMethodWithName("isSupported");
+              MethodSubject isSupported = main.uniqueMethodWithOriginalName("isSupported");
               assertThat(isSupported, isPresent());
               assertEquals(
                   kotlinc.is(KotlinCompilerVersion.KOTLINC_1_3_72) ? 1 : 0,
@@ -82,7 +82,7 @@
 
               // In general cases, null check won't be invoked only once or twice, hence no subtle
               // situation in double inlining.
-              MethodSubject containsArray = main.uniqueMethodWithName("containsArray");
+              MethodSubject containsArray = main.uniqueMethodWithOriginalName("containsArray");
               assertThat(containsArray, isPresent());
               assertEquals(0, countCall(containsArray, "checkParameterIsNotNull"));
             });
@@ -127,7 +127,7 @@
               ClassSubject main = inspector.clazz(MAIN);
               assertThat(main, isPresent());
 
-              MethodSubject method = main.uniqueMethodWithName(methodName);
+              MethodSubject method = main.uniqueMethodWithOriginalName(methodName);
               assertThat(method, isPresent());
               int arity = method.getMethod().getReference().getArity();
               assertEquals(
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
index 19458e2..7733d48 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -50,7 +50,7 @@
                         // Arity 2 should appear.
                         assertTrue(init.iterateInstructions(i -> i.isConstNumber(2)).hasNext());
 
-                        MethodSubject invoke = classSubject.uniqueMethodWithName("invoke");
+                        MethodSubject invoke = classSubject.uniqueMethodWithOriginalName("invoke");
                         assertThat(invoke, isPresent());
                         assertEquals(2, invoke.getMethod().getReference().proto.parameters.size());
                       }
@@ -66,7 +66,7 @@
                 inspector.forAllClasses(
                     classSubject -> {
                       if (classSubject.getOriginalDescriptor().contains("$js")) {
-                        MethodSubject get = classSubject.uniqueMethodWithName("get");
+                        MethodSubject get = classSubject.uniqueMethodWithOriginalName("get");
                         assertThat(get, isPresent());
                         assertEquals(3, get.getMethod().getReference().proto.parameters.size());
                       }
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
index 692f73b..959042b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -84,7 +84,7 @@
                       .count());
 
               // The field `INSTANCE` has been removed entirely.
-              FieldSubject instance = module.uniqueFieldWithName("INSTANCE");
+              FieldSubject instance = module.uniqueFieldWithOriginalName("INSTANCE");
               assertThat(instance, not(isPresent()));
 
               // The class initializer is no longer there.
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index 488271b..517fb4d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -65,7 +65,8 @@
               checkMethodPresenceInInput(clazz.getOriginalName(), testMethodSignature, true);
 
               // Find forMakeAndModel(...) after parameter removal.
-              MethodSubject testMethod = clazz.uniqueMethodWithName(testMethodSignature.name);
+              MethodSubject testMethod =
+                  clazz.uniqueMethodWithOriginalName(testMethodSignature.name);
               long ifzCount =
                   testMethod
                       .streamInstructions()
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
index 2f27ec3..81b06b4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
@@ -65,10 +65,10 @@
             codeInspector -> {
               final ClassSubject clazz = codeInspector.clazz("kotlin.Metadata");
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName("pn"), isPresent());
-              assertThat(clazz.uniqueMethodWithName("d1"), not(isPresent()));
-              assertThat(clazz.uniqueMethodWithName("d2"), not(isPresent()));
-              assertThat(clazz.uniqueMethodWithName("bv"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("pn"), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName("d1"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("d2"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("bv"), not(isPresent()));
             })
         .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
index 29b0027..6afe963 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
@@ -131,7 +131,7 @@
     // TODO(b/154348683): Assert equality between LibReference and Lib.
     // assertEqualMetadata(new CodeInspector(libReferenceJars.get(targetVersion)), inspector);
     ClassSubject lib = inspector.clazz(PKG_LIB + ".Lib");
-    MethodSubject funInline = lib.uniqueMethodWithName("funInline$main");
+    MethodSubject funInline = lib.uniqueMethodWithOriginalName("funInline$main");
     assertThat(funInline, isPresent());
     // TODO(b/154348683): Keep the inline method package private.
     // assertTrue(funInline.isPackagePrivate());
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
index eb588bb..2232747 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -186,15 +186,15 @@
     }
 
     // The backing field for the property in the companion, with @JvmField
-    FieldSubject elt2 = impl.uniqueFieldWithName("elt2");
+    FieldSubject elt2 = impl.uniqueFieldWithOriginalName("elt2");
     assertThat(elt2, isPresentAndNotRenamed());
 
-    FieldSubject companionObject = impl.uniqueFieldWithName("Companion");
+    FieldSubject companionObject = impl.uniqueFieldWithOriginalName("Companion");
     assertThat(companionObject, isPresentAndNotRenamed());
     assertEquals(companionObject.getFinalName(), kmClass.getCompanionObject());
 
     // Bridge for the property in the companion that needs a backing field.
-    MethodSubject elt1Bridge = impl.uniqueMethodWithName("access$getElt1$cp");
+    MethodSubject elt1Bridge = impl.uniqueMethodWithOriginalName("access$getElt1$cp");
     if (keptAll) {
       assertThat(elt1Bridge, isPresentAndNotRenamed());
     } else {
@@ -202,11 +202,11 @@
     }
 
     // With @JvmField, no bridge is added.
-    MethodSubject elt2Bridge = impl.uniqueMethodWithName("access$getElt2$cp");
+    MethodSubject elt2Bridge = impl.uniqueMethodWithOriginalName("access$getElt2$cp");
     assertThat(elt2Bridge, not(isPresent()));
 
     // For B$Companion.foo, which is a simple computation, no backing field needed, hence no bridge.
-    MethodSubject fooBridge = impl.uniqueMethodWithName("access$getFoo$cp");
+    MethodSubject fooBridge = impl.uniqueMethodWithOriginalName("access$getFoo$cp");
     assertThat(fooBridge, not(isPresent()));
 
     ClassSubject companion = inspector.clazz(companionClassName);
@@ -226,17 +226,17 @@
     kmProperty = kmClass.kmPropertyWithUniqueName("foo");
     assertThat(kmProperty, isPresent());
 
-    MethodSubject elt1Getter = companion.uniqueMethodWithName("getElt1");
+    MethodSubject elt1Getter = companion.uniqueMethodWithOriginalName("getElt1");
     assertThat(elt1Getter, isPresentAndNotRenamed());
 
     // Note that there is no getter for property with @JvmField.
-    MethodSubject elt2Getter = companion.uniqueMethodWithName("getElt2");
+    MethodSubject elt2Getter = companion.uniqueMethodWithOriginalName("getElt2");
     assertThat(elt2Getter, not(isPresent()));
 
-    MethodSubject fooGetter = companion.uniqueMethodWithName("getFoo");
+    MethodSubject fooGetter = companion.uniqueMethodWithOriginalName("getFoo");
     assertThat(fooGetter, isPresentAndNotRenamed());
 
-    MethodSubject barSetter = companion.uniqueMethodWithName("setBar");
+    MethodSubject barSetter = companion.uniqueMethodWithOriginalName("setBar");
     assertThat(barSetter, isPresentAndNotRenamed());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
index 99cdd63..eefafd8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -222,7 +222,7 @@
     // name by changing the import statement and the actual call.
     String[] methodNames = new String[] {"extension", "csHash", "longArrayHash", "myApply"};
     for (String methodName : methodNames) {
-      MethodSubject method = clazz.uniqueMethodWithName(methodName);
+      MethodSubject method = clazz.uniqueMethodWithOriginalName(methodName);
       assertThat(method, isPresentAndRenamed());
       String finalMethodName = method.getFinalName();
       kotlinSource =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
index 9ae2cb0..21ec2b1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -189,7 +189,7 @@
     ClassSubject sup = inspector.clazz(superClassName);
     assertThat(sup, isPresentAndRenamed());
 
-    MethodSubject foo = sup.uniqueMethodWithName("foo");
+    MethodSubject foo = sup.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresentAndRenamed());
 
     KmClassSubject kmClass = sup.getKmClass();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
index a4cc7fa..8fde8b1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
@@ -110,10 +110,10 @@
     ClassSubject libKt = inspector.clazz(libClassName);
     assertThat(libKt, isPresentAndNotRenamed());
 
-    MethodSubject methodSubject = libKt.uniqueMethodWithName("applyMap");
+    MethodSubject methodSubject = libKt.uniqueMethodWithOriginalName("applyMap");
     assertThat(methodSubject, isPresentAndNotRenamed());
 
-    methodSubject = libKt.uniqueMethodWithName("applyMap$default");
+    methodSubject = libKt.uniqueMethodWithOriginalName("applyMap$default");
     assertThat(methodSubject, isPresentAndNotRenamed());
 
     KmPackageSubject kmPackage = libKt.getKmPackage();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
index 435266f..18666b3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
@@ -118,13 +118,13 @@
     ClassSubject cls = inspector.clazz(className);
     assertThat(cls, isPresentAndNotRenamed());
 
-    MethodSubject foo = cls.uniqueMethodWithName("foo");
+    MethodSubject foo = cls.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresentAndNotRenamed());
 
     ClassSubject libKt = inspector.clazz(libClassName);
     assertThat(libKt, isPresentAndNotRenamed());
 
-    MethodSubject bar = libKt.uniqueMethodWithName("bar");
+    MethodSubject bar = libKt.uniqueMethodWithOriginalName("bar");
     assertThat(bar, isPresentAndNotRenamed());
 
     KmPackageSubject kmPackage = libKt.getKmPackage();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
index 11c9e7b..4168248 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
@@ -110,9 +110,9 @@
 
     ClassSubject util = inspector.clazz(utilClassName);
     assertThat(util, isPresentAndNotRenamed());
-    MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    MethodSubject commaJoinOfInt = util.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
     assertThat(commaJoinOfInt, isPresentAndNotRenamed());
-    MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+    MethodSubject joinOfInt = util.uniqueMethodWithOriginalName("joinOfInt");
     assertThat(joinOfInt, not(isPresent()));
 
     inspectMetadataForFacade(inspector, util);
@@ -155,9 +155,9 @@
 
     ClassSubject util = inspector.clazz(utilClassName);
     assertThat(util, isPresentAndNotRenamed());
-    MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    MethodSubject commaJoinOfInt = util.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
     assertThat(commaJoinOfInt, isPresentAndNotRenamed());
-    MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+    MethodSubject joinOfInt = util.uniqueMethodWithOriginalName("joinOfInt");
     assertThat(joinOfInt, isPresentAndRenamed());
 
     inspectMetadataForFacade(inspector, util);
@@ -187,9 +187,9 @@
     String signedClassName = PKG + ".multifileclass_lib.UtilKt__SignedKt";
     ClassSubject signed = inspector.clazz(signedClassName);
     assertThat(signed, isPresentAndRenamed());
-    MethodSubject commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    MethodSubject commaJoinOfInt = signed.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
     assertThat(commaJoinOfInt, isPresentAndNotRenamed());
-    MethodSubject joinOfInt = signed.uniqueMethodWithName("joinOfInt");
+    MethodSubject joinOfInt = signed.uniqueMethodWithOriginalName("joinOfInt");
     assertThat(joinOfInt, isPresentAndRenamed());
 
     // API entry is kept, hence the presence of Metadata.
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
index f93a28d..494d25d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -114,11 +114,11 @@
     ClassSubject person = inspector.clazz(personClassName);
     assertThat(person, isPresentAndNotRenamed());
 
-    FieldSubject backingField = person.uniqueFieldWithName("name");
+    FieldSubject backingField = person.uniqueFieldWithOriginalName("name");
     assertThat(backingField, isPresentAndRenamed());
-    MethodSubject getterForName = person.uniqueMethodWithName("getName");
+    MethodSubject getterForName = person.uniqueMethodWithOriginalName("getName");
     assertThat(getterForName, isPresentAndNotRenamed());
-    MethodSubject setterForName = person.uniqueMethodWithName("setName");
+    MethodSubject setterForName = person.uniqueMethodWithOriginalName("setName");
     assertThat(setterForName, not(isPresent()));
 
     // API entry is kept, hence the presence of Metadata.
@@ -250,7 +250,7 @@
     KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
     assertThat(familyName, not(isPresent()));
 
-    FieldSubject ageField = person.uniqueFieldWithName("age");
+    FieldSubject ageField = person.uniqueFieldWithOriginalName("age");
     assertThat(ageField, isAbsent());
 
     KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
index 5272541..2571322 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -164,7 +164,7 @@
     ClassSubject libKt = inspector.clazz(libKtClassName);
     assertThat(libKt, isPresentAndNotRenamed());
 
-    MethodSubject seq = libKt.uniqueMethodWithName("seq");
+    MethodSubject seq = libKt.uniqueMethodWithOriginalName("seq");
     assertThat(seq, isPresentAndNotRenamed());
 
     // API entry is kept, hence the presence of Metadata.
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
index cd667d3..a1b423d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
@@ -145,7 +145,7 @@
   private void inspectInterfaceWithCompanion(CodeInspector inspector) {
     ClassSubject itf = inspector.clazz(PKG_LIB + ".InterfaceWithCompanion");
     assertThat(itf, isPresent());
-    MethodSubject greet = itf.uniqueMethodWithName("greet");
+    MethodSubject greet = itf.uniqueMethodWithOriginalName("greet");
     assertThat(greet, isPresent());
 
     ClassSubject itfCompanion = inspector.clazz(PKG_LIB + ".InterfaceWithCompanion$Companion");
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
index 783b9f1..69643e1 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
@@ -65,7 +65,7 @@
           // cast.
           ClassSubject clazz = inspector.clazz(Main.class);
           assertThat(clazz, isPresentAndNotRenamed());
-          MethodSubject main = clazz.uniqueMethodWithName("main");
+          MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
           assertThat(main, isPresent());
           List<CheckCastInstructionSubject> checkCasts =
               main.streamInstructions()
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
index 47bd62e..f5aae43 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
@@ -95,17 +95,17 @@
     CodeInspector inspector = compileResult.inspector();
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
-    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooMethodSubject, isPresent());
     ClassSubject main2ClassSubject = inspector.clazz(Main2.class);
     assertThat(main2ClassSubject, isPresent());
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
-    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
     assertThat(barMethodSubject, isPresent());
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
     assertThat(bazMethodSubject, isPresent());
     assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
     assertThat(barMethodSubject, invokesMethod(bazMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
index 013fdd3..b2f82c7 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
@@ -95,19 +95,19 @@
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
-    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
     assertThat(barMethodSubject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
     assertThat(bazMethodSubject, isPresent());
 
     assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
index 50e65c9..6f97deb 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
@@ -99,23 +99,23 @@
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
-    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooMethodSubject, isPresent());
 
     MethodSubject notCalledAtStartupMethodSubject =
-        mainClassSubject.uniqueMethodWithName("notCalledAtStartup");
+        mainClassSubject.uniqueMethodWithOriginalName("notCalledAtStartup");
     assertThat(notCalledAtStartupMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
     assertThat(barMethodSubject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
     assertThat(bazMethodSubject, isPresent());
 
     assertThat(notCalledAtStartupMethodSubject, invokesMethod(barMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
index 4d59d9b..6cc29ca 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
@@ -112,7 +112,7 @@
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
-    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
@@ -121,7 +121,7 @@
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    MethodSubject fooASubject = aClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooASubject = aClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooASubject, isPresent());
 
     assertThat(fooMethodSubject, invokesMethod(fooASubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
index 480abb7..82e102e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
@@ -104,13 +104,13 @@
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
-    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    MethodSubject fooAMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+    MethodSubject fooAMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
     assertThat(fooAMethodSubject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
index ee3a60f..1143ca2 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
@@ -69,7 +69,7 @@
               assertThat(bSubject, isPresent());
               ClassSubject mainSubject = inspector.clazz(Main.class);
               assertThat(mainSubject, isPresentAndNotRenamed());
-              MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithName("main");
+              MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithOriginalName("main");
               assertThat(mainMethodSubject, isPresentAndNotRenamed());
               assertTrue(
                   mainMethodSubject
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
index e472056..d48f547 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
@@ -103,7 +103,7 @@
         .inspect(
             inspector -> {
               MethodSubject testMethodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("test");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertThat(
                   testMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
index ee69b91..41ccb91 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
@@ -64,7 +64,7 @@
         .inspect(
             inspector -> {
               MethodSubject getSystemService =
-                  inspector.clazz(Main.class).uniqueMethodWithName("getSystemService");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("getSystemService");
               assertThat(getSystemService, isPresent());
               // We should never rebind this call to LibraryBase::getSystemService since this can
               // cause errors when verifying the code on a device where the image has a definition
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java b/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
index 2d1b98c..63bc8a6 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
@@ -47,7 +47,7 @@
     assertThat(classSubject, isPresent());
     assertTrue(
         classSubject
-            .uniqueMethodWithName("main")
+            .uniqueMethodWithOriginalName("main")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeVirtual)
             .noneMatch(
diff --git a/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java b/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
index eaac9ca..35e8c37 100644
--- a/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
+++ b/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
@@ -130,7 +130,7 @@
 
     ClassSubject utilsClassSubject = inspector.clazz(Utils.class);
     assertThat(utilsClassSubject, isPresent());
-    assertThat(utilsClassSubject.uniqueMethodWithName("throwException"), isPresent());
+    assertThat(utilsClassSubject.uniqueMethodWithOriginalName("throwException"), isPresent());
     assertEquals(1, utilsClassSubject.allMethods().size());
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java b/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
index 9038f76..7ec987b 100644
--- a/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
@@ -85,18 +85,18 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject base = inspector.clazz(Base.class);
     assertThat(base, isPresentAndRenamed());
-    MethodSubject foo = base.uniqueMethodWithName("foo");
+    MethodSubject foo = base.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresentAndRenamed());
 
     ClassSubject sub1 = inspector.clazz(Sub1.class);
     assertThat(sub1, isPresentAndRenamed());
-    MethodSubject fooInSub1 = sub1.uniqueMethodWithName("foo");
+    MethodSubject fooInSub1 = sub1.uniqueMethodWithOriginalName("foo");
     assertThat(fooInSub1, isPresentAndRenamed());
     assertEquals(foo.getFinalName(), fooInSub1.getFinalName());
 
     ClassSubject sub2 = inspector.clazz(Sub1.class);
     assertThat(sub2, isPresentAndRenamed());
-    MethodSubject fooInSub2 = sub2.uniqueMethodWithName("foo");
+    MethodSubject fooInSub2 = sub2.uniqueMethodWithOriginalName("foo");
     assertThat(fooInSub2, isPresentAndRenamed());
     assertEquals(foo.getFinalName(), fooInSub2.getFinalName());
   }
diff --git a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
index 97073ac..cd8e931 100644
--- a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
@@ -96,7 +96,7 @@
       throws NoSuchMethodException {
     ClassSubject superInterface = inspector.clazz(SuperInterface.class);
     assertThat(superInterface, isPresentAndRenamed());
-    MethodSubject foo1 = superInterface.uniqueMethodWithName("foo");
+    MethodSubject foo1 = superInterface.uniqueMethodWithOriginalName("foo");
     assertThat(foo1, isPresentAndRenamed());
     ClassSubject subInterface = inspector.clazz(SubInterface.class);
     assertThat(subInterface, isPresentAndRenamed());
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinification.java b/src/test/java/com/android/tools/r8/naming/EnumMinification.java
index 3cf01e0..95ff741 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinification.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinification.java
@@ -68,13 +68,13 @@
     // The class and fields - including the method valueOf - can be renamed. Only the values()
     // method needs to be.
     assertThat(clazz, isPresentAndRenamed());
-    assertThat(clazz.uniqueFieldWithName("VALUE1"), isAbsent());
-    assertThat(clazz.uniqueFieldWithName("VALUE2"), isAbsent());
-    assertThat(clazz.uniqueFieldWithName("$VALUES"), isPresentAndRenamed());
+    assertThat(clazz.uniqueFieldWithOriginalName("VALUE1"), isAbsent());
+    assertThat(clazz.uniqueFieldWithOriginalName("VALUE2"), isAbsent());
+    assertThat(clazz.uniqueFieldWithOriginalName("$VALUES"), isPresentAndRenamed());
     assertThat(
-        clazz.uniqueMethodWithName("valueOf"),
+        clazz.uniqueMethodWithOriginalName("valueOf"),
         valueOfKept ? isPresentAndRenamed() : not(isPresent()));
-    assertThat(clazz.uniqueMethodWithName("values"), isPresentAndNotRenamed());
+    assertThat(clazz.uniqueMethodWithOriginalName("values"), isPresentAndNotRenamed());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
index 7d0d809..d8e0168 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
@@ -38,10 +38,10 @@
             .assertSuccessWithOutput(expectedOutput)
             .inspector();
 
-    FieldSubject f1Subject = inspector.clazz(A.class).uniqueFieldWithName("f1");
+    FieldSubject f1Subject = inspector.clazz(A.class).uniqueFieldWithOriginalName("f1");
     assertThat(f1Subject, isPresent());
 
-    FieldSubject f3Subject = inspector.clazz(C.class).uniqueFieldWithName("f3");
+    FieldSubject f3Subject = inspector.clazz(C.class).uniqueFieldWithOriginalName("f3");
     assertThat(f3Subject, isPresent());
 
     assertNotEquals(f1Subject.getFinalName(), f3Subject.getFinalName());
diff --git a/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java b/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
index 165d0f7..0fc9365 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
@@ -108,11 +108,16 @@
         .assertSuccessWithOutputLines("2HELLO WORLD", "2HELLO WORLD")
         .inspect(
             inspector -> {
-              assertEquals("a", inspector.clazz(A.class).uniqueFieldWithName("f1").getFinalName());
-              assertEquals("a", inspector.clazz(B.class).uniqueFieldWithName("f0").getFinalName());
-              assertEquals("b", inspector.clazz(B.class).uniqueFieldWithName("f2").getFinalName());
-              assertEquals("a", inspector.clazz(C.class).uniqueFieldWithName("f0").getFinalName());
-              assertEquals("b", inspector.clazz(C.class).uniqueFieldWithName("f3").getFinalName());
+              assertEquals(
+                  "a", inspector.clazz(A.class).uniqueFieldWithOriginalName("f1").getFinalName());
+              assertEquals(
+                  "a", inspector.clazz(B.class).uniqueFieldWithOriginalName("f0").getFinalName());
+              assertEquals(
+                  "b", inspector.clazz(B.class).uniqueFieldWithOriginalName("f2").getFinalName());
+              assertEquals(
+                  "a", inspector.clazz(C.class).uniqueFieldWithOriginalName("f0").getFinalName());
+              assertEquals(
+                  "b", inspector.clazz(C.class).uniqueFieldWithOriginalName("f3").getFinalName());
             });
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java b/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
index e3a8047..28d39db 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
@@ -42,9 +42,9 @@
         .assertSuccessWithOutputLines("true", "42", "Hello World!")
         .inspect(
             inspector -> {
-              FieldSubject foo = inspector.clazz(I.class).uniqueFieldWithName("foo");
-              FieldSubject bar = inspector.clazz(J.class).uniqueFieldWithName("bar");
-              FieldSubject baz = inspector.clazz(A.class).uniqueFieldWithName("baz");
+              FieldSubject foo = inspector.clazz(I.class).uniqueFieldWithOriginalName("foo");
+              FieldSubject bar = inspector.clazz(J.class).uniqueFieldWithOriginalName("bar");
+              FieldSubject baz = inspector.clazz(A.class).uniqueFieldWithOriginalName("baz");
               assertThat(foo, isPresentAndRenamed());
               assertThat(bar, isPresentAndRenamed());
               assertThat(baz, isPresentAndRenamed());
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
index 6597cb0..dc7f93e 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
@@ -144,7 +144,7 @@
     assertEquals(countInMain, renamedYetFoundIdentifierCount);
 
     ClassSubject aClass = inspector.clazz("adaptclassstrings.A");
-    MethodSubject bar = aClass.uniqueMethodWithName("bar");
+    MethodSubject bar = aClass.uniqueMethodWithOriginalName("bar");
     assertThat(bar, isPresent());
     verifyPresenceOfConstString(bar);
     renamedYetFoundIdentifierCount = countRenamedClassIdentifier(inspector, bar);
@@ -188,7 +188,7 @@
     assertEquals(2, constStringInstructions.size());
 
     ClassSubject b = inspector.clazz("getmembers.B");
-    MethodSubject inliner = b.uniqueMethodWithName("inliner");
+    MethodSubject inliner = b.uniqueMethodWithOriginalName("inliner");
     assertThat(inliner, isPresent());
     constStringInstructions = getRenamedMemberIdentifierConstStrings(a, inliner);
     assertEquals(1, constStringInstructions.size());
diff --git a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
index 57bd145..8fd083f 100644
--- a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
@@ -75,9 +75,9 @@
             codeInspector -> {
               ClassSubject clazz = codeInspector.clazz(Main.class);
               assertThat(clazz, isPresent());
-              MethodSubject aSubject = clazz.uniqueMethodWithName("a");
+              MethodSubject aSubject = clazz.uniqueMethodWithOriginalName("a");
               assertThat(aSubject.getFinalName(), anyOf(is("x"), is("y")));
-              MethodSubject bSubject = clazz.uniqueMethodWithName("b");
+              MethodSubject bSubject = clazz.uniqueMethodWithOriginalName("b");
               assertThat(bSubject.getFinalName(), anyOf(is("x"), is("y")));
             });
   }
diff --git a/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java b/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
index 166b2e1..d7baa95 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
@@ -142,10 +142,13 @@
               assertEquals(aFoo.getFinalName(), cFoo.getFinalName());
 
               // Ensure that all SAM interfaces has same method name.
-              final MethodSubject i1Foo = codeInspector.clazz(I1.class).uniqueMethodWithName("foo");
-              final MethodSubject i2Foo = codeInspector.clazz(I2.class).uniqueMethodWithName("foo");
+              final MethodSubject i1Foo =
+                  codeInspector.clazz(I1.class).uniqueMethodWithOriginalName("foo");
+              final MethodSubject i2Foo =
+                  codeInspector.clazz(I2.class).uniqueMethodWithOriginalName("foo");
               assertEquals(i1Foo.getFinalName(), i2Foo.getFinalName());
-              final MethodSubject i3Foo = codeInspector.clazz(I3.class).uniqueMethodWithName("foo");
+              final MethodSubject i3Foo =
+                  codeInspector.clazz(I3.class).uniqueMethodWithOriginalName("foo");
               assertEquals(i1Foo.getFinalName(), i3Foo.getFinalName());
 
               // Ensure C has the correct name for the interface method.
@@ -154,7 +157,8 @@
               assertEquals(cIFoo.getFinalName(), i1Foo.getFinalName());
 
               // Ensure that I4.foo(int) has the same name as I3.foo(int).
-              final MethodSubject i4Foo = codeInspector.clazz(I4.class).uniqueMethodWithName("foo");
+              final MethodSubject i4Foo =
+                  codeInspector.clazz(I4.class).uniqueMethodWithOriginalName("foo");
               assertEquals(i3Foo.getFinalName(), i4Foo.getFinalName());
             });
   }
diff --git a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
index cda6322..b7176ab 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
@@ -62,14 +62,14 @@
     assertThat(classSubject, isPresent());
 
     FieldSubject fieldSubject =
-        classSubject.asFoundClassSubject().uniqueFieldWithName("a", Reference.BOOL);
+        classSubject.asFoundClassSubject().uniqueFieldWithOriginalName("a", Reference.BOOL);
     assertThat(fieldSubject, isPresentAndNotRenamed());
 
-    FieldSubject helloFieldSubject = classSubject.uniqueFieldWithName("hello");
+    FieldSubject helloFieldSubject = classSubject.uniqueFieldWithOriginalName("hello");
     assertThat(helloFieldSubject, isPresent());
     assertEquals(overloadAggressively ? "a" : "b", helloFieldSubject.getFinalName());
 
-    FieldSubject worldFieldSubject = classSubject.uniqueFieldWithName("world");
+    FieldSubject worldFieldSubject = classSubject.uniqueFieldWithOriginalName("world");
     assertThat(worldFieldSubject, isPresent());
     assertEquals(overloadAggressively ? "a" : "c", worldFieldSubject.getFinalName());
   }
diff --git a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
index 9079f61..487498f 100644
--- a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
@@ -157,7 +157,7 @@
     assertFalse(inspector.clazz("naming044.sub.SubB").getFinalName().contains("."));
 
     // Method naming044.B.m would be renamed.
-    MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithName("m");
+    MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithOriginalName("m");
     assertNotEquals("m", mMethodSubject.getMethod().getName().toSourceString());
   }
 
@@ -197,7 +197,7 @@
         b.getDexProgramClass().getType().getPackageName());
 
     // method naming044.B.m would be renamed.
-    MethodSubject mMethodSubject = b.uniqueMethodWithName("m");
+    MethodSubject mMethodSubject = b.uniqueMethodWithOriginalName("m");
     assertNotEquals("m", mMethodSubject.getMethod().getName().toSourceString());
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
index cd9d54c..2176526 100644
--- a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
@@ -78,9 +78,9 @@
     assertThat(viewModel, isPresentAndRenamed(minification));
     ClassSubject subViewModel = inspector.clazz(SubViewModel.class);
     assertThat(subViewModel, isPresentAndRenamed(minification));
-    MethodSubject viewModelClear = viewModel.uniqueMethodWithName("clear");
+    MethodSubject viewModelClear = viewModel.uniqueMethodWithOriginalName("clear");
     assertThat(viewModelClear, isPresentAndRenamed(minification));
-    MethodSubject subViewModelClear = subViewModel.uniqueMethodWithName("clear");
+    MethodSubject subViewModelClear = subViewModel.uniqueMethodWithOriginalName("clear");
     assertThat(subViewModelClear, isPresentAndRenamed(minification));
     assertEquals(viewModelClear.getFinalName(), subViewModelClear.getFinalName());
     if (!minification) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
index c4b3181..d7e6e8a 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
@@ -69,10 +69,10 @@
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithName("f1");
+    FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f1");
     assertThat(f1FieldSubject, isPresent());
 
-    FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithName("a");
+    FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithOriginalName("a");
     assertThat(aFieldSubject, isPresent());
 
     if (reserveName) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
index 38bcbad..4994263 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
@@ -83,22 +83,22 @@
     ClassSubject kClassSubject = inspector.clazz(K.class);
     assertThat(kClassSubject, isPresent());
 
-    FieldSubject f1FieldSubject = aClassSubject.uniqueFieldWithName("f1");
+    FieldSubject f1FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f1");
     assertThat(f1FieldSubject, isPresent());
 
-    FieldSubject f2FieldSubject = bClassSubject.uniqueFieldWithName("f2");
+    FieldSubject f2FieldSubject = bClassSubject.uniqueFieldWithOriginalName("f2");
     assertThat(f2FieldSubject, isPresent());
 
-    FieldSubject f3FieldSubject = iClassSubject.uniqueFieldWithName("f3");
+    FieldSubject f3FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f3");
     assertThat(f3FieldSubject, isPresent());
 
-    FieldSubject f4FieldSubject = jClassSubject.uniqueFieldWithName("f4");
+    FieldSubject f4FieldSubject = jClassSubject.uniqueFieldWithOriginalName("f4");
     assertThat(f4FieldSubject, isPresent());
 
-    FieldSubject f5FieldSubject = kClassSubject.uniqueFieldWithName("f5");
+    FieldSubject f5FieldSubject = kClassSubject.uniqueFieldWithOriginalName("f5");
     assertThat(f5FieldSubject, isPresent());
 
-    FieldSubject aFieldSubject = cClassSubject.uniqueFieldWithName("a");
+    FieldSubject aFieldSubject = cClassSubject.uniqueFieldWithOriginalName("a");
     assertThat(aFieldSubject, isPresent());
 
     if (reserveName) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
index 65c62b8..8298bed 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
@@ -67,11 +67,11 @@
     ClassSubject jClassSubject = inspector.clazz(J.class);
     assertThat(jClassSubject, isPresent());
 
-    FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithName("f1");
+    FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f1");
     assertThat(f1FieldSubject, isPresent());
     assertThat(f1FieldSubject, isPresentAndRenamed());
 
-    FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithName("a");
+    FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithOriginalName("a");
     assertThat(aFieldSubject, isPresent());
 
     if (reserveName) {
@@ -119,7 +119,7 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithName("f2");
+    FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f2");
     assertThat(f2FieldSubject, isPresent());
     assertThat(f2FieldSubject, isPresentAndRenamed());
 
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
index 3c264ae..58dfa65 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
@@ -59,7 +59,7 @@
     ClassSubject testClassForFieldSubject = inspector.clazz(A.class);
     assertThat(testClassForFieldSubject, isPresent());
 
-    FieldSubject aFieldSubject = testClassForFieldSubject.uniqueFieldWithName("a");
+    FieldSubject aFieldSubject = testClassForFieldSubject.uniqueFieldWithOriginalName("a");
     assertThat(aFieldSubject, isPresent());
 
     // Fields are visited/renamed according to the class hierarchy order. Thus, the field A.a will
@@ -92,14 +92,14 @@
     ClassSubject aSub1ClassSubject = inspector.clazz(ASub1.class);
     assertThat(aSub1ClassSubject, isPresent());
 
-    FieldSubject fooFieldSubject = aSub1ClassSubject.uniqueFieldWithName("foo");
+    FieldSubject fooFieldSubject = aSub1ClassSubject.uniqueFieldWithOriginalName("foo");
     assertThat(fooFieldSubject, isPresentAndRenamed());
     assertNotEquals("a", fooFieldSubject.getFinalName());
 
     ClassSubject aSub2ClassSubject = inspector.clazz(ASub2.class);
     assertThat(aSub2ClassSubject, isPresent());
 
-    FieldSubject barFieldSubject = aSub2ClassSubject.uniqueFieldWithName("bar");
+    FieldSubject barFieldSubject = aSub2ClassSubject.uniqueFieldWithOriginalName("bar");
     assertThat(barFieldSubject, isPresentAndRenamed());
     assertNotEquals("a", barFieldSubject.getFinalName());
 
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
index 599799e..2760aec 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
@@ -60,7 +60,7 @@
     ClassSubject iClassSubject = inspector.clazz(I.class);
     assertThat(iClassSubject, isPresent());
 
-    FieldSubject aFieldSubject = iClassSubject.uniqueFieldWithName("a");
+    FieldSubject aFieldSubject = iClassSubject.uniqueFieldWithOriginalName("a");
     assertThat(aFieldSubject, isPresent());
 
     // Interface fields are visited/renamed before fields on classes. Thus, the interface field I.a
@@ -93,7 +93,7 @@
     ClassSubject jClassSubject = inspector.clazz(J.class);
     assertThat(jClassSubject, isPresent());
 
-    FieldSubject f1FieldSubject = jClassSubject.uniqueFieldWithName("f1");
+    FieldSubject f1FieldSubject = jClassSubject.uniqueFieldWithOriginalName("f1");
     assertThat(f1FieldSubject, isPresent());
     assertThat(f1FieldSubject, isPresentAndRenamed());
     assertEquals("b", f1FieldSubject.getFinalName());
@@ -101,7 +101,7 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithName("f2");
+    FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f2");
     assertThat(f2FieldSubject, isPresent());
     assertThat(f2FieldSubject, isPresentAndRenamed());
     assertEquals("c", f2FieldSubject.getFinalName());
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
index 3d4b859..b0f1a96 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
@@ -104,10 +104,10 @@
               ClassSubject clazzB = codeInspector.clazz(B.class);
               assertTrue(clazzB.isPresent());
               assertTrue(clazzB.isRenamed());
-              FieldSubject foo = clazzB.uniqueFieldWithName("foo");
+              FieldSubject foo = clazzB.uniqueFieldWithOriginalName("foo");
               assertTrue(foo.isPresent());
               assertFalse(foo.isRenamed());
-              MethodSubject bar = clazzB.uniqueMethodWithName("bar");
+              MethodSubject bar = clazzB.uniqueMethodWithOriginalName("bar");
               assertTrue(bar.isPresent());
               assertFalse(bar.isRenamed());
             });
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
index 26873f4..2657ae8 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
@@ -84,7 +84,7 @@
                 codeInspector -> {
                   ClassSubject clazz = codeInspector.clazz(Interface.class);
                   assertThat(clazz, isPresent());
-                  MethodSubject computeSubject = clazz.uniqueMethodWithName("compute");
+                  MethodSubject computeSubject = clazz.uniqueMethodWithOriginalName("compute");
                   assertThat(computeSubject, isPresent());
                   assertTrue(computeSubject.isRenamed());
                 });
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
index f527ead..afb0b75 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
@@ -113,19 +113,19 @@
                   ClassSubject clazzA = inspector.clazz(A.class);
                   assertThat(clazzA, isPresent());
                   assertEquals("a", clazzA.getFinalName());
-                  FieldSubject fieldA = clazzA.uniqueFieldWithName("fieldA");
+                  FieldSubject fieldA = clazzA.uniqueFieldWithOriginalName("fieldA");
                   assertThat(fieldA, isPresent());
                   assertEquals("a", fieldA.getFinalName());
-                  MethodSubject methodA = clazzA.uniqueMethodWithName("methodA");
+                  MethodSubject methodA = clazzA.uniqueMethodWithOriginalName("methodA");
                   assertThat(methodA, isPresent());
                   assertEquals("a", methodA.getFinalName());
-                  FieldSubject fieldB = clazzA.uniqueFieldWithName("fieldB");
+                  FieldSubject fieldB = clazzA.uniqueFieldWithOriginalName("fieldB");
                   assertThat(fieldB, isPresent());
                   assertTrue(fieldB.isRenamed());
-                  MethodSubject methodB = clazzA.uniqueMethodWithName("methodB");
+                  MethodSubject methodB = clazzA.uniqueMethodWithOriginalName("methodB");
                   assertThat(methodB, isPresent());
                   assertTrue(methodB.isRenamed());
-                  MethodSubject methodC = clazzA.uniqueMethodWithName("methodC");
+                  MethodSubject methodC = clazzA.uniqueMethodWithOriginalName("methodC");
                   assertThat(methodC, isPresent());
                   assertFalse(methodC.isRenamed());
                 });
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
index afa76f5..8b4f4e3 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
@@ -103,14 +103,14 @@
                   ClassSubject clazzA = inspector.clazz(A.class);
                   assertThat(clazzA, isPresent());
                   assertEquals("baz", clazzA.getFinalName());
-                  FieldSubject fieldA = clazzA.uniqueFieldWithName("fieldA");
+                  FieldSubject fieldA = clazzA.uniqueFieldWithOriginalName("fieldA");
                   assertThat(fieldA, isPresent());
                   assertEquals("foo", fieldA.getFinalName());
-                  MethodSubject methodA = clazzA.uniqueMethodWithName("methodA");
+                  MethodSubject methodA = clazzA.uniqueMethodWithOriginalName("methodA");
                   assertThat(methodA, isPresent());
                   assertEquals("bar", methodA.getFinalName());
-                  assertThat(clazzA.uniqueFieldWithName("fieldB"), isPresentAndRenamed());
-                  assertThat(clazzA.uniqueMethodWithName("methodB"), isPresentAndRenamed());
+                  assertThat(clazzA.uniqueFieldWithOriginalName("fieldB"), isPresentAndRenamed());
+                  assertThat(clazzA.uniqueMethodWithOriginalName("methodB"), isPresentAndRenamed());
                 });
     // Ensure that the proguard map is extended with all the new minified names.
     for (String pgLine : pgMap) {
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
index 40ba160..5db4da0 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
@@ -65,7 +65,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(SignatureTest.class);
               assertThat(clazz, isPresent());
-              FieldSubject field = clazz.uniqueFieldWithName("field");
+              FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
               assertThat(field, isPresent());
               assertThat(field.getFinalSignatureAttribute(), containsString("foo"));
             });
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
index d195bd3..4eb4585 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
@@ -74,10 +74,10 @@
         .inspector();
     ClassSubject enumSubject = inspector.clazz(RENAMED_NAME);
     assertThat(enumSubject, isPresent());
-    FieldSubject fieldX = enumSubject.uniqueFieldWithName("STATE_A");
+    FieldSubject fieldX = enumSubject.uniqueFieldWithOriginalName("STATE_A");
     assertThat(fieldX, isPresent());
     assertEquals("state_X", fieldX.getFinalName());
-    FieldSubject fieldY = enumSubject.uniqueFieldWithName("STATE_B");
+    FieldSubject fieldY = enumSubject.uniqueFieldWithOriginalName("STATE_B");
     assertThat(fieldY, isPresent());
     assertEquals("state_Y", fieldY.getFinalName());
   }
diff --git a/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
index 968123a..48ae678 100644
--- a/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
@@ -75,8 +75,10 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    FieldSubject fld = inspector.clazz(CONCRETE1.getTypeName().replace("Concrete1", "Abs"))
-        .uniqueFieldWithName("strField");
+    FieldSubject fld =
+        inspector
+            .clazz(CONCRETE1.getTypeName().replace("Concrete1", "Abs"))
+            .uniqueFieldWithOriginalName("strField");
     assertThat(fld, isPresent());
 
     ClassSubject main = inspector.clazz(MAIN);
diff --git a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
index fb9c53e..3e4d30f 100644
--- a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
+++ b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
@@ -64,7 +64,7 @@
                 genericTypeDescriptor = genericType.getFinalDescriptor();
               }
               String expectedSignature = "Ljava/util/List<" + genericTypeDescriptor + ">;";
-              FieldSubject list = inspector.clazz(A.class).uniqueFieldWithName("list");
+              FieldSubject list = inspector.clazz(A.class).uniqueFieldWithOriginalName("list");
               assertThat(list, isPresent());
               assertEquals(expectedSignature, list.getFinalSignatureAttribute());
             })
diff --git a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
index 0add817..24fd0b2 100644
--- a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
+++ b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
@@ -39,7 +39,7 @@
             inspector -> {
               ClassSubject greetingBase = inspector.clazz(Greeting.getGreetingBase());
               assertThat(greetingBase, isPresent());
-              FieldSubject greeting = greetingBase.uniqueFieldWithName("greeting");
+              FieldSubject greeting = greetingBase.uniqueFieldWithOriginalName("greeting");
               assertThat(greeting, isPresentAndRenamed());
               assertNotEquals("a", greeting.getFinalName());
             });
@@ -86,7 +86,7 @@
             inspector -> {
               ClassSubject base = inspector.clazz(TestClassBase.class);
               assertThat(base, isPresent());
-              MethodSubject foo = base.uniqueMethodWithName("foo");
+              MethodSubject foo = base.uniqueMethodWithOriginalName("foo");
               assertThat(foo, isPresentAndRenamed());
               assertNotEquals("a", foo.getFinalName());
             });
diff --git a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
index ad2f639..ba6fab5 100644
--- a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
+++ b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
@@ -110,7 +110,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject holder = inspector.clazz(SomeLogic.class);
     assertThat(holder, isPresentAndNotRenamed());
-    MethodSubject someMethod = holder.uniqueMethodWithName("someMethod");
+    MethodSubject someMethod = holder.uniqueMethodWithOriginalName("someMethod");
     assertThat(someMethod, isPresentAndNotRenamed());
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
index 8d07717..a987575 100644
--- a/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
@@ -92,18 +92,18 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject base = inspector.clazz(Base.class);
     assertThat(base, isPresentAndRenamed());
-    MethodSubject a = base.uniqueMethodWithName("a");
+    MethodSubject a = base.uniqueMethodWithOriginalName("a");
     assertThat(a, isPresentAndNotRenamed());
 
     ClassSubject sub1 = inspector.clazz(Sub1.class);
     assertThat(sub1, isPresentAndRenamed());
-    MethodSubject aInSub1 = sub1.uniqueMethodWithName("a");
+    MethodSubject aInSub1 = sub1.uniqueMethodWithOriginalName("a");
     assertThat(aInSub1, isPresentAndNotRenamed());
     assertEquals(a.getFinalName(), aInSub1.getFinalName());
 
     ClassSubject sub2 = inspector.clazz(Sub1.class);
     assertThat(sub2, isPresentAndRenamed());
-    MethodSubject aInSub2 = sub2.uniqueMethodWithName("a");
+    MethodSubject aInSub2 = sub2.uniqueMethodWithOriginalName("a");
     assertThat(aInSub2, isPresentAndNotRenamed());
     assertEquals(a.getFinalName(), aInSub2.getFinalName());
   }
diff --git a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
index 470b542..2de209b 100644
--- a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
@@ -11,7 +11,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
@@ -50,9 +49,7 @@
                 .setSuper(DescriptorUtils.javaTypeToDescriptor(Interface.class.getTypeName()))
                 .transform())
         .build();
-    testForExternalR8(
-            parameters.getBackend(),
-            parameters.isCfRuntime() ? parameters.getRuntime() : TestRuntime.getCheckedInJdk11())
+    testForExternalR8(parameters.getBackend())
         .addProgramFiles(classFiles)
         .addTestingAnnotationsAsProgramClasses()
         .enableAssertions(false)
diff --git a/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java b/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
index 8771ff4..ffdda98 100644
--- a/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
+++ b/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
@@ -142,7 +142,7 @@
     assertThat(testClass, isPresent());
 
     // Test the totally unused method.
-    MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+    MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
     assertThat(staticMethod, isPresent());
     assertEquals(minify, staticMethod.isRenamed());
     if (shrinker.isR8()) {
@@ -152,7 +152,7 @@
     }
 
     // Test an indirectly referred method.
-    staticMethod = testClass.uniqueMethodWithName("staticMethod");
+    staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
     assertThat(staticMethod, isPresent());
     assertEquals(minify, staticMethod.isRenamed());
     boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
@@ -193,7 +193,7 @@
     assertThat(testClass, isPresent());
 
     // Test the totally unused method.
-    MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+    MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
     assertThat(staticMethod, isPresent());
     assertEquals(minify, staticMethod.isRenamed());
     if (shrinker.isR8()) {
@@ -203,7 +203,7 @@
     }
 
     // Test an indirectly referred method.
-    staticMethod = testClass.uniqueMethodWithName("staticMethod");
+    staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
     assertThat(staticMethod, isPresent());
     assertEquals(minify, staticMethod.isRenamed());
     boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
@@ -259,11 +259,11 @@
     assertThat(testClass, isPresent());
 
     // Test the totally unused method.
-    MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+    MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
     assertThat(staticMethod, not(isPresent()));
 
     // Test an indirectly referred method.
-    staticMethod = testClass.uniqueMethodWithName("staticMethod");
+    staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
     assertThat(staticMethod, isPresent());
     assertEquals(minify, staticMethod.isRenamed());
     boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
index b07255b..db9020d 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
@@ -62,7 +62,7 @@
         .inspectStackTrace(
             (stackTrace, inspector) -> {
               MethodSubject methodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("call");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("call");
               assertThat(methodSubject, isPresent());
               List<InstructionSubject> getClassCalls =
                   methodSubject
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
index b005549..8362ed6 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
@@ -65,7 +65,7 @@
                 inspector -> {
                   ClassSubject fooClass = inspector.clazz(Foo.class);
                   assertThat(fooClass, isPresent());
-                  MethodSubject inlineable = fooClass.uniqueMethodWithName("inlineable");
+                  MethodSubject inlineable = fooClass.uniqueMethodWithOriginalName("inlineable");
                   assertThat(inlineable, not(isPresent()));
                 });
     compileResult
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
index f3718cd..a68715a 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
@@ -99,7 +99,7 @@
           ClassSubject fooClass = codeInspector.clazz(Foo.class);
           assertThat(fooClass, isPresent());
           // We are not inlining this because resolution fails
-          assertThat(fooClass.uniqueMethodWithName("inlinable"), isPresent());
+          assertThat(fooClass.uniqueMethodWithOriginalName("inlinable"), isPresent());
         });
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
index 99531f1..90552b3 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
@@ -67,7 +67,7 @@
             (stackTrace, inspector) -> {
               ClassSubject callerClass = inspector.clazz(Caller.class);
               assertThat(callerClass, isPresent());
-              MethodSubject outerCaller = callerClass.uniqueMethodWithName("outerCaller");
+              MethodSubject outerCaller = callerClass.uniqueMethodWithOriginalName("outerCaller");
               assertThat(outerCaller, isPresentAndRenamed());
               assertThat(stackTrace, isSame(expectedStackTrace));
             });
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
index 1e2140c..f8ad999 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
@@ -43,7 +43,8 @@
         .compile()
         .inspect(
             inspector -> {
-              MethodSubject aMethodSubject = inspector.clazz(A.class).uniqueMethodWithName("m");
+              MethodSubject aMethodSubject =
+                  inspector.clazz(A.class).uniqueMethodWithOriginalName("m");
               assertThat(aMethodSubject, isPresent());
               assertTrue(
                   aMethodSubject
@@ -55,7 +56,8 @@
                       .anyMatch(instruction -> instruction.isConstString("A: Null")));
 
               // TODO(b/190154391): B.m() is always called with non-null.
-              MethodSubject bMethodSubject = inspector.clazz(B.class).uniqueMethodWithName("m");
+              MethodSubject bMethodSubject =
+                  inspector.clazz(B.class).uniqueMethodWithOriginalName("m");
               assertThat(bMethodSubject, isPresent());
               assertTrue(
                   bMethodSubject
@@ -67,7 +69,8 @@
                       .anyMatch(instruction -> instruction.isConstString("B: Null")));
 
               // TODO(b/190154391): C.m() is always called with null.
-              MethodSubject cMethodSubject = inspector.clazz(C.class).uniqueMethodWithName("m");
+              MethodSubject cMethodSubject =
+                  inspector.clazz(C.class).uniqueMethodWithOriginalName("m");
               assertThat(cMethodSubject, isPresent());
               assertTrue(
                   cMethodSubject
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
index 20b82f0..cef5521 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
@@ -48,7 +48,7 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject checkNotNullSubject =
-                  mainClassSubject.uniqueMethodWithName("checkNotNull");
+                  mainClassSubject.uniqueMethodWithOriginalName("checkNotNull");
               assertThat(checkNotNullSubject, isPresent());
               assertEquals(1, checkNotNullSubject.getProgramMethod().getReference().getArity());
             })
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
index a728f8c..023b012 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
@@ -51,7 +51,7 @@
               assertThat(hostClassSubject, isPresent());
               assertEquals(1, hostClassSubject.allMethods().size());
               assertThat(hostClassSubject.clinit(), isAbsent());
-              assertThat(hostClassSubject.uniqueMethodWithName("keepHost"), isPresent());
+              assertThat(hostClassSubject.uniqueMethodWithOriginalName("keepHost"), isPresent());
 
               ClassSubject companionClassSubject = inspector.clazz(Host.Companion.class);
               assertThat(companionClassSubject, isPresent());
@@ -59,7 +59,7 @@
               assertThat(companionClassSubject.init(), isAbsent());
 
               MethodSubject greetMethodSubject =
-                  companionClassSubject.uniqueMethodWithName("greet");
+                  companionClassSubject.uniqueMethodWithOriginalName("greet");
               assertThat(greetMethodSubject, isStatic());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
index 3e410db..d1f817a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
@@ -47,7 +47,7 @@
               assertThat(mainClassSubject, isPresent());
 
               MethodSubject identityMethodSubject =
-                  mainClassSubject.uniqueMethodWithName("identity");
+                  mainClassSubject.uniqueMethodWithOriginalName("identity");
               assertThat(identityMethodSubject, isPresent());
               assertTrue(identityMethodSubject.getProgramMethod().getParameters().isEmpty());
               assertTrue(identityMethodSubject.getProgramMethod().getReturnType().isVoidType());
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
index 562c3b5..23b1aa9 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
@@ -56,7 +56,8 @@
                       .streamInstructions()
                       .noneMatch(InstructionSubject::isStaticGet));
 
-              MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertEquals(0, testMethodSubject.getProgramMethod().getReference().getArity());
               assertTrue(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
index 86ab638..dc9b490 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
@@ -53,10 +53,10 @@
               ClassSubject companionClassSubject = inspector.clazz(Host.Companion.class);
               assertThat(companionClassSubject, isPresent());
               assertEquals(4, companionClassSubject.allMethods().size());
-              assertThat(companionClassSubject.uniqueMethodWithName("foo"), isStatic());
-              assertThat(companionClassSubject.uniqueMethodWithName("bar"), isStatic());
-              assertThat(companionClassSubject.uniqueMethodWithName("baz"), isStatic());
-              assertThat(companionClassSubject.uniqueMethodWithName("qux"), isStatic());
+              assertThat(companionClassSubject.uniqueMethodWithOriginalName("foo"), isStatic());
+              assertThat(companionClassSubject.uniqueMethodWithOriginalName("bar"), isStatic());
+              assertThat(companionClassSubject.uniqueMethodWithOriginalName("baz"), isStatic());
+              assertThat(companionClassSubject.uniqueMethodWithOriginalName("qux"), isStatic());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Foo!", "Bar!", "Baz!", "Qux!", "Baz!");
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
index 65c3ce8..7daf43b 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
@@ -56,7 +56,8 @@
                       .streamInstructions()
                       .noneMatch(InstructionSubject::isConstNull));
 
-              MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertEquals(2, testMethodSubject.getProgramMethod().getReference().getArity());
               assertEquals(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
index 0df2eff..0e32f15 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
@@ -45,7 +45,7 @@
             inspector -> {
               // The test() method has been changed to have return type void.
               MethodSubject testMethodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("test");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertTrue(testMethodSubject.getProgramMethod().getReturnType().isVoidType());
 
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
index bca23cb..25af8f6 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
@@ -49,7 +49,7 @@
         .inspect(
             inspector -> {
               MethodSubject companionMethodSubject =
-                  inspector.clazz(Host.Companion.class).uniqueMethodWithName("greet");
+                  inspector.clazz(Host.Companion.class).uniqueMethodWithOriginalName("greet");
               assertThat(companionMethodSubject, isStatic());
 
               MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
index 42d8535..10324b8 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
@@ -57,14 +57,16 @@
               assertThat(bClassSubject, isPresent());
 
               // Method testA(I) should be rewritten to testA(A).
-              MethodSubject testAMethodSubject = mainClassSubject.uniqueMethodWithName("testA");
+              MethodSubject testAMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("testA");
               assertThat(testAMethodSubject, isPresent());
               assertEquals(
                   aClassSubject.getFinalName(),
                   testAMethodSubject.getProgramMethod().getParameter(0).getTypeName());
 
               // Method testB(I) should be rewritten to testB(B).
-              MethodSubject testBMethodSubject = mainClassSubject.uniqueMethodWithName("testB");
+              MethodSubject testBMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("testB");
               assertThat(testBMethodSubject, isPresent());
               assertEquals(
                   bClassSubject.getFinalName(),
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
index fcf44bb..b38703a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
@@ -47,7 +47,8 @@
             inspector -> {
               // The test() methods have been changed to have return type void.
               for (Class<?> clazz : new Class<?>[] {A.class, B.class}) {
-                MethodSubject testMethodSubject = inspector.clazz(clazz).uniqueMethodWithName("m");
+                MethodSubject testMethodSubject =
+                    inspector.clazz(clazz).uniqueMethodWithOriginalName("m");
                 assertThat(testMethodSubject, isPresent());
                 assertTrue(testMethodSubject.getProgramMethod().getReturnType().isVoidType());
               }
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
index b1faa74..d8d8797 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
@@ -56,14 +56,15 @@
               assertThat(aClassSubject, isPresent());
 
               // Return type of get() should be strengthened to A.
-              MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithName("get");
+              MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("get");
               assertThat(getMethodSubject, isPresent());
               assertEquals(
                   aClassSubject.getFinalName(),
                   getMethodSubject.getProgramMethod().getReturnType().getTypeName());
 
               // Method consume(I) should be rewritten to consume(A).
-              MethodSubject testBMethodSubject = mainClassSubject.uniqueMethodWithName("consume");
+              MethodSubject testBMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("consume");
               assertThat(testBMethodSubject, isPresent());
               assertEquals(
                   aClassSubject.getFinalName(),
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
index cee9ab5..e6e00cb 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
@@ -50,13 +50,14 @@
               assertThat(mainClassSubject, isPresent());
 
               // The test() method has been optimized.
-              MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertEquals(0, testMethodSubject.getProgramMethod().getParameters().size());
               assertTrue(
                   testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
 
-              assertThat(mainClassSubject.uniqueMethodWithName("dead"), isAbsent());
+              assertThat(mainClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello", "Hello", "Hello");
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
index 1764b30..86a584a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
@@ -51,14 +51,15 @@
 
               // The test1(), test2(), and test3() methods have been optimized.
               for (int i = 1; i <= 3; i++) {
-                MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test" + i);
+                MethodSubject testMethodSubject =
+                    mainClassSubject.uniqueMethodWithOriginalName("test" + i);
                 assertThat(testMethodSubject, isPresent());
                 assertEquals(0, testMethodSubject.getProgramMethod().getParameters().size());
                 assertTrue(
                     testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
               }
 
-              assertThat(mainClassSubject.uniqueMethodWithName("dead"), isAbsent());
+              assertThat(mainClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
index dd93e33..4e857f5 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
@@ -56,7 +56,8 @@
                       .streamInstructions()
                       .noneMatch(InstructionSubject::isConstNumber));
 
-              MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+              MethodSubject testMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("test");
               assertThat(testMethodSubject, isPresent());
               assertEquals(0, testMethodSubject.getProgramMethod().getReference().getArity());
             })
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
index 993ca6b..a756ee3 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
@@ -53,7 +53,7 @@
             inspector -> {
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
-              MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithName("m");
+              MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
               assertThat(aMethodSubject, isPresent());
               assertEquals(0, aMethodSubject.getProgramMethod().getReference().getArity());
               assertTrue(
@@ -63,7 +63,8 @@
 
               ClassSubject aSub1ClassSubject = inspector.clazz(ASub1.class);
               assertThat(aSub1ClassSubject, isPresent());
-              MethodSubject aSub1MethodSubject = aSub1ClassSubject.uniqueMethodWithName("m");
+              MethodSubject aSub1MethodSubject =
+                  aSub1ClassSubject.uniqueMethodWithOriginalName("m");
               assertThat(aSub1MethodSubject, isPresent());
               assertEquals(0, aSub1MethodSubject.getProgramMethod().getReference().getArity());
               assertTrue(
@@ -74,7 +75,7 @@
               ClassSubject aSub2Sub1ClassSubject = inspector.clazz(ASub2Sub1.class);
               assertThat(aSub2Sub1ClassSubject, isPresent());
               MethodSubject aSub2Sub1MethodSubject =
-                  aSub2Sub1ClassSubject.uniqueMethodWithName("m");
+                  aSub2Sub1ClassSubject.uniqueMethodWithOriginalName("m");
               assertThat(aSub2Sub1MethodSubject, isPresent());
               assertEquals(0, aSub2Sub1MethodSubject.getProgramMethod().getReference().getArity());
               assertTrue(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
index 25ce6a4..44b319b 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
@@ -46,7 +46,8 @@
         .compile()
         .inspect(
             inspector -> {
-              MethodSubject aMethodSubject = inspector.clazz(A.class).uniqueMethodWithName("m");
+              MethodSubject aMethodSubject =
+                  inspector.clazz(A.class).uniqueMethodWithOriginalName("m");
               assertThat(aMethodSubject, isPresent());
               assertTrue(
                   aMethodSubject
@@ -57,7 +58,8 @@
                       .streamInstructions()
                       .anyMatch(instruction -> instruction.isConstString("A: Null")));
 
-              MethodSubject b2MethodSubject = inspector.clazz(B2.class).uniqueMethodWithName("m");
+              MethodSubject b2MethodSubject =
+                  inspector.clazz(B2.class).uniqueMethodWithOriginalName("m");
               assertThat(b2MethodSubject, isPresent());
               assertTrue(
                   b2MethodSubject
@@ -68,7 +70,8 @@
                       .streamInstructions()
                       .noneMatch(instruction -> instruction.isConstString("B2: Null")));
 
-              MethodSubject b3MethodSubject = inspector.clazz(B3.class).uniqueMethodWithName("m");
+              MethodSubject b3MethodSubject =
+                  inspector.clazz(B3.class).uniqueMethodWithOriginalName("m");
               assertThat(b3MethodSubject, isPresent());
               assertTrue(
                   b3MethodSubject
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
index e226a85..b59861c 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
@@ -46,7 +46,7 @@
               for (Class<?> clazz : new Class[] {A.class, C.class}) {
                 ClassSubject aClassSubject = inspector.clazz(clazz);
                 assertThat(aClassSubject, isPresent());
-                MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithName("m");
+                MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
                 assertThat(aMethodSubject, isPresent());
                 assertTrue(aMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
               }
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
index 84ee636..b9b9866 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
@@ -43,7 +43,8 @@
               ClassSubject aClassSubject = inspector.clazz(Main.class);
               assertThat(aClassSubject, isPresent());
               assertThat(
-                  aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+                  aClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), not(isFinal())));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Main.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
index 115b180..5452c48 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
@@ -47,7 +47,8 @@
             inspector -> {
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
-              assertThat(aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+              assertThat(
+                  aClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
index d134ecb..eb04b78 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
@@ -49,11 +49,13 @@
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
               assertThat(
-                  iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+                  iClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), not(isFinal())));
 
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
-              assertThat(aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+              assertThat(
+                  aClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()", "C.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
index dd316ac..a91566e 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
@@ -49,16 +49,19 @@
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertThat(
-                  aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+                  aClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), not(isFinal())));
 
               ClassSubject bClassSubject = inspector.clazz(B.class);
               assertThat(bClassSubject, isPresent());
               assertThat(
-                  bClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+                  bClassSubject.uniqueMethodWithOriginalName("m"),
+                  allOf(isPresent(), not(isFinal())));
 
               ClassSubject cClassSubject = inspector.clazz(C.class);
               assertThat(cClassSubject, isPresent());
-              assertThat(cClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+              assertThat(
+                  cClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("A.m()", "B.m()", "C.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
index 12d62c9..e90481a 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
@@ -50,13 +50,13 @@
               TypeSubject bTypeSubject = inspector.clazz(B.class).asTypeSubject();
 
               MethodSubject fooMethodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("foo");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
 
               for (String methodName : new String[] {"bar", "baz"}) {
                 MethodSubject methodSubject =
-                    inspector.clazz(Main.class).uniqueMethodWithName(methodName);
+                    inspector.clazz(Main.class).uniqueMethodWithOriginalName(methodName);
                 assertThat(methodSubject, isPresent());
                 assertThat(methodSubject, hasParameters(bTypeSubject, aTypeSubject));
               }
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
index 3b8abab..21723d9 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
@@ -55,12 +55,13 @@
               TypeSubject bTypeSubject = bClassSubject.asTypeSubject();
 
               // A.foo(B, A) is kept.
-              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
 
               // B.foo(B, A) overrides kept method.
-              MethodSubject otherFooMethodSubject = bClassSubject.uniqueMethodWithName("foo");
+              MethodSubject otherFooMethodSubject =
+                  bClassSubject.uniqueMethodWithOriginalName("foo");
               assertThat(otherFooMethodSubject, isPresent());
               assertThat(otherFooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
             })
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
index 1e6a4e5..1383fef 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
@@ -49,12 +49,12 @@
               TypeSubject bTypeSubject = inspector.getTypeSubject(B.class.getTypeName());
 
               MethodSubject fooMethodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("foo");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
 
               MethodSubject libraryOverrideMethodSubject =
-                  inspector.clazz(Program.class).uniqueMethodWithName("m");
+                  inspector.clazz(Program.class).uniqueMethodWithOriginalName("m");
               assertThat(libraryOverrideMethodSubject, isPresent());
               assertThat(libraryOverrideMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
             })
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
index e4507b5..2e5098b 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
@@ -61,7 +61,7 @@
               TypeSubject barTypeSubject = inspector.clazz(Bar.class).asTypeSubject();
 
               // Main.bar() has parameter annotations [@Bar, @Foo].
-              MethodSubject barMethodSubject = mainClassSubject.uniqueMethodWithName("bar");
+              MethodSubject barMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("bar");
               assertThat(barMethodSubject, isPresent());
               assertThat(barMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
               assertThat(
@@ -70,7 +70,7 @@
                       ImmutableList.of(barTypeSubject), ImmutableList.of(fooTypeSubject)));
 
               // Main.baz() has parameter annotations [, @Foo].
-              MethodSubject bazMethodSubject = mainClassSubject.uniqueMethodWithName("baz");
+              MethodSubject bazMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("baz");
               assertThat(bazMethodSubject, isPresent());
               assertThat(bazMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
               assertThat(
@@ -79,7 +79,7 @@
                       ImmutableList.of(), ImmutableList.of(fooTypeSubject)));
 
               // Main.qux() has parameter annotations [@Foo, ].
-              MethodSubject quxMethodSubject = mainClassSubject.uniqueMethodWithName("qux");
+              MethodSubject quxMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("qux");
               assertThat(quxMethodSubject, isPresent());
               assertThat(quxMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
               assertThat(
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
index de0dfe3..ba776e4 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
@@ -55,13 +55,14 @@
               TypeSubject aTypeSubject = aClassSubject.asTypeSubject();
               TypeSubject bTypeSubject = bClassSubject.asTypeSubject();
 
-              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+              MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertThat(fooMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
 
               // TODO(b/173398086): Consider rewriting B.foo(B, A) to B.foo(A, B, C) instead of
               //  B.foo$1(A, B).
-              MethodSubject otherFooMethodSubject = bClassSubject.uniqueMethodWithName("foo$1");
+              MethodSubject otherFooMethodSubject =
+                  bClassSubject.uniqueMethodWithOriginalName("foo$1");
               assertThat(otherFooMethodSubject, isPresent());
               assertThat(otherFooMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
             })
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
index dcde130..546c7ce 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
@@ -48,7 +48,7 @@
 
               // Should not be normalized as there is no sharing of protos.
               MethodSubject fooMethodSubject =
-                  inspector.clazz(Main.class).uniqueMethodWithName("foo");
+                  inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
               assertThat(fooMethodSubject, isPresent());
               assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
             })
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
index 15ed09c..598101f 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
@@ -74,10 +74,10 @@
     ClassSubject barClassSubject = inspector.clazz(Bar.class);
     assertThat(barClassSubject, isPresentAndRenamed());
 
-    MethodSubject helloMethodSubject = barClassSubject.uniqueMethodWithName("hello");
+    MethodSubject helloMethodSubject = barClassSubject.uniqueMethodWithOriginalName("hello");
     assertThat(helloMethodSubject, isPresentAndRenamed());
 
-    MethodSubject worldMethodSubject = barClassSubject.uniqueMethodWithName("world");
+    MethodSubject worldMethodSubject = barClassSubject.uniqueMethodWithOriginalName("world");
     assertThat(worldMethodSubject, isPresentAndRenamed());
 
     assertTrue(residualArtProfileConsumer.finished);
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
index 80bb288..ff9003a 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
@@ -68,7 +68,7 @@
     ClassSubject greeterClassSubject = inspector.clazz(Greeter.class);
     assertThat(greeterClassSubject, isPresentAndRenamed());
 
-    MethodSubject greetMethodSubject = greeterClassSubject.uniqueMethodWithName("greet");
+    MethodSubject greetMethodSubject = greeterClassSubject.uniqueMethodWithOriginalName("greet");
     assertThat(greetMethodSubject, isPresentAndRenamed());
 
     assertTrue(residualArtProfileConsumer.finished);
diff --git a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
index da88bc6..f93737b 100644
--- a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
@@ -75,7 +75,7 @@
               assertThat(streamClassSubject, isPresentAndNotRenamed());
 
               MethodSubject forEachMethodSubject =
-                  streamClassSubject.uniqueMethodWithName("forEach");
+                  streamClassSubject.uniqueMethodWithOriginalName("forEach");
               assertThat(
                   forEachMethodSubject,
                   isPresentAndRenamed(
diff --git a/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java b/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
index 879786b..d2275df 100644
--- a/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
@@ -66,8 +66,8 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(clazz);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueFieldWithName("unused"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("main"), isPresent());
+    assertThat(classSubject.uniqueFieldWithOriginalName("unused"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("main"), isPresent());
   }
 }
 
diff --git a/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java b/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
index 063976a..e6644ad 100644
--- a/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
@@ -32,10 +32,10 @@
 
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("methodA"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("methodB"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("methodC"), isPresent());
-    assertThat(classSubject.uniqueMethodWithName("methodD"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("methodA"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("methodB"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("methodC"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("methodD"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java b/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
index 78694ea..aba69ff 100644
--- a/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
+++ b/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
@@ -45,10 +45,10 @@
         .inspector();
     ClassSubject clazz = inspector.clazz(testClass);
     assertThat(clazz, isPresent());
-    MethodSubject foo = clazz.uniqueMethodWithName("foo");
+    MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     checkNoMoveWide(foo);
-    MethodSubject bar = clazz.uniqueMethodWithName("bar");
+    MethodSubject bar = clazz.uniqueMethodWithOriginalName("bar");
     assertThat(bar, isPresent());
     checkNoMoveWide(bar);
   }
diff --git a/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java b/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
index fa3661e..6db35da 100644
--- a/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
+++ b/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
@@ -50,7 +50,7 @@
             .inspector();
     ClassSubject clazz = inspector.clazz("FlafKt");
     assertTrue(clazz.isPresent());
-    MethodSubject method = clazz.uniqueMethodWithName("box");
+    MethodSubject method = clazz.uniqueMethodWithOriginalName("box");
     assertTrue(method.isPresent());
     return method;
   }
diff --git a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
index 41d6a49..47c33fb 100644
--- a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
@@ -68,13 +68,14 @@
   private void checkDeadCodeThrowInTryRange(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject, isPresent());
-    MethodSubject method = classSubject.uniqueMethodWithName("synchronizedMethod");
+    MethodSubject method = classSubject.uniqueMethodWithOriginalName("synchronizedMethod");
     assertThat(method, isPresent());
 
     // Ensure that the "throwNpe" method remains and that it was not inlined by checking that no
     // allocations of NullPointerException are in the method.
     assertTrue(method.streamInstructions().noneMatch(InstructionSubject::isNewInstance));
-    assertThat(inspector.clazz(TestClass.class).uniqueMethodWithName("throwNpe"), isPresent());
+    assertThat(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("throwNpe"), isPresent());
 
     // Source has 2 catch ranges:
     // 1st try catch is the source range, 2nd is the compiler inserted catch over monitor-exit.
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
index 23a5047..38b94ee 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
@@ -66,7 +66,7 @@
             inspector -> {
               ClassSubject mainClass = inspector.clazz(Main.class);
               assertThat(mainClass, isPresentAndNotRenamed());
-              MethodSubject main = mainClass.uniqueMethodWithName("main");
+              MethodSubject main = mainClass.uniqueMethodWithOriginalName("main");
               assertThat(main, isPresentAndNotRenamed());
               ClassSubject aClass = inspector.clazz(A.class);
               assertThat(aClass, isPresentAndNotRenamed());
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java
new file mode 100644
index 0000000..a49759f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.repackage;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RepackageKeepClassMembersTest extends RepackageTestBase {
+
+  public RepackageKeepClassMembersTest(
+      String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+    super(flattenPackageHierarchyOrRepackageClasses, parameters);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .apply(this::configureRepackaging)
+        .addKeepRules(
+            "-keepclassmembers class * extends " + typeName(Base.class) + " { <fields>; }")
+        .addKeepMainRule(Main.class)
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class, typeName(Sub.class))
+        .inspect(this::inspect)
+        // TODOD(b/250671873): Should not repackage class.
+        .assertSuccessWithOutputLines("Could not find " + typeName(Sub.class));
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject clazz = inspector.clazz(Sub.class);
+    assertThat(clazz, isPresent());
+    // TODOD(b/250671873): Should not repackage class.
+    assertThat(Sub.class, isRepackaged(inspector));
+    assertThat(clazz.uniqueFieldWithOriginalName("hashCodeCache"), isPresentAndNotRenamed());
+    assertThat(clazz.uniqueMethodWithOriginalName("calculateHashCode"), isPresentAndRenamed());
+  }
+
+  public static class Base {}
+
+  @NeverClassInline
+  public static class Sub extends Base {
+
+    public int hashCodeCache;
+
+    @NeverInline
+    public int calculateHashCode() {
+      if (hashCodeCache != -1) {
+        return hashCodeCache;
+      }
+      hashCodeCache = Objects.hash(Sub.class);
+      return hashCodeCache;
+    }
+
+    @Override
+    public int hashCode() {
+      return calculateHashCode();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println(new Sub().hashCode());
+      }
+      try {
+        Class<?> subClass = Class.forName(args[0]);
+        Object subInstance = subClass.getDeclaredConstructor().newInstance();
+        subClass.getMethod("calculateHashCode").invoke(subInstance);
+        System.out.println("Hello World!");
+      } catch (Exception e) {
+        System.out.println("Could not find " + args[0]);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
new file mode 100644
index 0000000..a208857
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.repackage;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/** This is a reproduction of b/250671873. */
+@RunWith(Parameterized.class)
+public class RepackageProtectedInSamePackageTest extends RepackageTestBase {
+
+  public RepackageProtectedInSamePackageTest(
+      String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+    super(flattenPackageHierarchyOrRepackageClasses, parameters);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .apply(this::configureRepackaging)
+        .addKeepRules(
+            "-keepclassmembers,allowobfuscation class * extends "
+                + typeName(Base.class)
+                + " { <fields>; }")
+        .addKeepMainRule(Main.class)
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class)
+        .inspect(this::inspect)
+        .assertSuccessWithOutputLines("Hello World!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    // TODO(b/250671873): We should be able to repackage the Sub class since the only reference
+    //  to Sub.class is in the same package and we have allowobfuscation.
+    ClassSubject clazz = inspector.clazz(Sub.class);
+    assertThat(clazz, isPresent());
+    assertThat(Sub.class, isNotRepackaged(inspector));
+    assertThat(clazz.uniqueFieldWithOriginalName("hashCodeCache"), isPresentAndRenamed());
+    assertThat(clazz.uniqueMethodWithOriginalName("calculateHashCode"), isPresentAndRenamed());
+  }
+
+  public static class Base {}
+
+  @NeverClassInline
+  public static class Sub extends Base {
+
+    protected int hashCodeCache;
+
+    @NeverInline
+    protected int calculateHashCode() {
+      if (hashCodeCache != -1) {
+        return hashCodeCache;
+      }
+      hashCodeCache = Objects.hash(Sub.class);
+      return hashCodeCache;
+    }
+
+    @Override
+    public int hashCode() {
+      return calculateHashCode();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println(new Sub().hashCode());
+      }
+      System.out.println("Hello World!");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
index 3db9028..23a5cfd 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
@@ -54,7 +54,7 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject greeterBase = inspector.clazz(GreeterBase.class);
     assertThat(greeterBase, isPresent());
-    assertThat(greeterBase.uniqueMethodWithName("greetBridge"), isPresent());
+    assertThat(greeterBase.uniqueMethodWithOriginalName("greetBridge"), isPresent());
   }
 
   public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
index 4f028fb..4f6f672 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
@@ -67,21 +67,22 @@
     String clinitFieldName = inspector.getFactory().objectMembers.clinitField.name.toSourceString();
     if (enableMemberValuePropagationAnnotations) {
       // No $r8$clinit field should have been synthesized since we can use the HELLO field.
-      assertThat(repackagedClassSubject.uniqueFieldWithName(clinitFieldName), not(isPresent()));
-      assertThat(repackagedClassSubject.uniqueFieldWithName("HELLO"), isPresent());
+      assertThat(
+          repackagedClassSubject.uniqueFieldWithOriginalName(clinitFieldName), not(isPresent()));
+      assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("HELLO"), isPresent());
 
       // Verify that the WORLD field has been removed.
-      assertThat(repackagedClassSubject.uniqueFieldWithName("WORLD"), not(isPresent()));
+      assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("WORLD"), not(isPresent()));
 
       // Verify that the class was not repackaged.
       assertThat(StaticMemberValuePropagation.class, isNotRepackaged(inspector));
     } else {
       // Verify that a $r8$clinit field was synthesized.
-      assertThat(repackagedClassSubject.uniqueFieldWithName(clinitFieldName), isPresent());
+      assertThat(repackagedClassSubject.uniqueFieldWithOriginalName(clinitFieldName), isPresent());
 
       // Verify that both fields have been removed.
-      assertThat(repackagedClassSubject.uniqueFieldWithName("HELLO"), not(isPresent()));
-      assertThat(repackagedClassSubject.uniqueFieldWithName("WORLD"), not(isPresent()));
+      assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("HELLO"), not(isPresent()));
+      assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("WORLD"), not(isPresent()));
 
       // Verify that the class was repackaged.
       assertThat(StaticMemberValuePropagation.class, isRepackaged(inspector));
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java b/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
index 8edefd8..0b057db 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
@@ -61,8 +61,8 @@
         .inspect(
             inspector -> {
               ClassSubject clazz = inspector.clazz(SingleStaticTargetLookupTest.class);
-              MethodSubject main = clazz.uniqueMethodWithName("main");
-              MethodSubject staticFoo = clazz.uniqueMethodWithName("staticFoo");
+              MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
+              MethodSubject staticFoo = clazz.uniqueMethodWithOriginalName("staticFoo");
               assertThat(clazz, isPresent());
               assertThat(main, isPresent());
               assertEquals(keepFoo, staticFoo.isPresent());
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
index aa827c8..5390779 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
@@ -149,7 +149,7 @@
   private void assertCallingClassCallsTarget(
       Class<?> callerClass, AppView<?> appView, DexMethod target) {
     CodeInspector inspector = new CodeInspector(appView.appInfo().app());
-    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
     assertTrue(
         foo.streamInstructions()
             .anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
index 50f4428..79c89e8 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
@@ -132,7 +132,7 @@
   private void assertCallingClassCallsTarget(
       Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod method) {
     CodeInspector inspector = new CodeInspector(appInfo.app());
-    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
     assertTrue(
         foo.streamInstructions()
             .anyMatch(
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
index 1a6485c..dd66e5d5 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
@@ -124,7 +124,7 @@
   private void assertCallingClassCallsTarget(
       Class<?> callerClass, AppView<?> appView, DexMethod target) {
     CodeInspector inspector = new CodeInspector(appView.appInfo().app());
-    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
     assertTrue(
         foo.streamInstructions()
             .anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
index 5fddce3..efbbd16 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
@@ -160,7 +160,7 @@
   private void assertCallingClassCallsTarget(
       Class<?> callerClass, AppView<?> appView, DexMethod target) {
     CodeInspector inspector = new CodeInspector(appView.appInfo().app());
-    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
     assertTrue(
         foo.streamInstructions()
             .anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
index 31a8904..e1d4d99 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
@@ -121,7 +121,7 @@
   private void assertCallingClassCallsTarget(
       Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod target) {
     CodeInspector inspector = new CodeInspector(appInfo.app());
-    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+    MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
     assertTrue(
         foo.streamInstructions()
             .anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java b/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
index 029fc63..e2f71f5 100644
--- a/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
+++ b/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
@@ -81,14 +81,15 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    MethodSubject foo = inspector.clazz(
-        PublicClass.class.getTypeName().replace("PublicClass", "AbstractClass"))
-        .uniqueMethodWithName("foo");
+    MethodSubject foo =
+        inspector
+            .clazz(PublicClass.class.getTypeName().replace("PublicClass", "AbstractClass"))
+            .uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
 
     ClassSubject main = inspector.clazz(PublicClassExtender.class);
     assertThat(main, isPresent());
-    MethodSubject methodSubject = main.uniqueMethodWithName("delegate");
+    MethodSubject methodSubject = main.uniqueMethodWithOriginalName("delegate");
     assertThat(methodSubject, isPresent());
 
     methodSubject
diff --git a/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
index 820be96..cb07033 100644
--- a/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
@@ -97,10 +97,14 @@
     ClassSubject classSubject = inspector.clazz(Result.class);
     assertThat(classSubject, isPresent());
     assertThat(
-        classSubject.uniqueMethodWithName("methodWhichAccessInstanceMethod"), not(isPresent()));
+        classSubject.uniqueMethodWithOriginalName("methodWhichAccessInstanceMethod"),
+        not(isPresent()));
     assertThat(
-        classSubject.uniqueMethodWithName("methodWhichAccessInstanceField"), not(isPresent()));
-    assertThat(classSubject.uniqueMethodWithName("methodWhichAccessStaticField"), not(isPresent()));
+        classSubject.uniqueMethodWithOriginalName("methodWhichAccessInstanceField"),
+        not(isPresent()));
+    assertThat(
+        classSubject.uniqueMethodWithOriginalName("methodWhichAccessStaticField"),
+        not(isPresent()));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
index 8eb9f47..7f2dac3 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -107,13 +107,14 @@
         .assertFailureWithErrorThatMatches(containsString("main"))
         .inspectStackTrace(
             (stackTrace, codeInspector) -> {
-              MethodSubject mainSubject = codeInspector.clazz(MAIN).uniqueMethodWithName("main");
+              MethodSubject mainSubject =
+                  codeInspector.clazz(MAIN).uniqueMethodWithOriginalName("main");
               LinePosition inlineStack =
                   LinePosition.stack(
                       LinePosition.create(
                           kotlinInspector
                               .clazz("retrace.InlineFunctionsInSameFileKt")
-                              .uniqueMethodWithName("foo")
+                              .uniqueMethodWithOriginalName("foo")
                               .asFoundMethodSubject(),
                           1,
                           8,
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index e95e5a9..d42b54f 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -74,14 +74,14 @@
   private FoundMethodSubject inlineExceptionStatic(CodeInspector kotlinInspector) {
     return kotlinInspector
         .clazz("retrace.InlineFunctionKt")
-        .uniqueMethodWithName("inlineExceptionStatic")
+        .uniqueMethodWithOriginalName("inlineExceptionStatic")
         .asFoundMethodSubject();
   }
 
   private FoundMethodSubject inlineExceptionInstance(CodeInspector kotlinInspector) {
     return kotlinInspector
         .clazz("retrace.InlineFunction")
-        .uniqueMethodWithName("inlineExceptionInstance")
+        .uniqueMethodWithOriginalName("inlineExceptionInstance")
         .asFoundMethodSubject();
   }
 
@@ -115,7 +115,8 @@
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
             (stackTrace, codeInspector) -> {
-              MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+              MethodSubject mainSubject =
+                  codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
               LinePosition inlineStack =
                   LinePosition.stack(
                       LinePosition.create(
@@ -145,7 +146,8 @@
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionInstance"))
         .inspectStackTrace(
             (stackTrace, codeInspector) -> {
-              MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+              MethodSubject mainSubject =
+                  codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
               LinePosition inlineStack =
                   LinePosition.stack(
                       LinePosition.create(
@@ -181,7 +183,8 @@
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
             (stackTrace, codeInspector) -> {
-              MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+              MethodSubject mainSubject =
+                  codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
               LinePosition inlineStack =
                   LinePosition.stack(
                       LinePosition.create(
@@ -213,7 +216,8 @@
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
             (stackTrace, codeInspector) -> {
-              MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+              MethodSubject mainSubject =
+                  codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
               LinePosition inlineStack =
                   LinePosition.stack(
                       LinePosition.create(
diff --git a/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java b/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java
new file mode 100644
index 0000000..96d52ab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RenamedSignatureClashTest extends TestBase {
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  private final ClassReference renamedHolder = Reference.classFromTypeName("A");
+  private final ClassReference originalHolder =
+      Reference.classFromTypeName("com.android.tools.r8.naming.retrace.Main");
+
+  private final String mapping =
+      StringUtils.lines(
+          "# { id: 'com.android.tools.r8.mapping', version: '1.0' }",
+          originalHolder.getTypeName() + " -> " + renamedHolder.getTypeName() + ":",
+          "  void some.moved.Method.someMethod(int) -> a",
+          "  void methodWithRemovedArgument(int) -> a",
+          "  # { id: 'com.android.tools.r8.synthesized' }");
+
+  @Test
+  public void testAmbiguousResult() {
+    Retracer retracer =
+        Retracer.createDefault(
+            ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
+    MethodReference methodReference =
+        Reference.methodFromDescriptor(renamedHolder.getDescriptor(), "a", "(I)V");
+    RetraceMethodResult retraceMethodResult = retracer.retraceMethod(methodReference);
+    assertTrue(retraceMethodResult.isAmbiguous());
+    retraceMethodResult.stream()
+        .forEach(
+            result -> {
+              String method = result.getRetracedMethod().asKnown().getMethodReference().toString();
+              if (method.equals("Lsome/moved/Method;someMethod(I)V")) {
+                assertFalse(result.isCompilerSynthesized());
+              } else {
+                assertEquals(
+                    originalHolder.getDescriptor() + "methodWithRemovedArgument(I)V", method);
+                assertTrue(result.isCompilerSynthesized());
+              }
+            });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java b/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java
new file mode 100644
index 0000000..6817079
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RetraceOutsideLineRangeTest extends TestBase {
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  private final ClassReference someOtherClassOriginal =
+      Reference.classFromTypeName("some.other.Class");
+  private final ClassReference someOtherClassRenamed = Reference.classFromTypeName("a");
+  private final ClassReference someClassOriginal = Reference.classFromTypeName("some.Class");
+  private final ClassReference someClassRenamed = Reference.classFromTypeName("b");
+
+  private final String mapping =
+      someOtherClassOriginal.getTypeName()
+          + " -> "
+          + someOtherClassRenamed.getTypeName()
+          + ":\n"
+          + "  void method1():42:42 -> a\n"
+          + someClassOriginal.getTypeName()
+          + " -> "
+          + someClassRenamed.getTypeName()
+          + ":\n"
+          + "  28:28:void foo.bar.inlinee():92:92 -> a\n"
+          + "  1:3:void method2():11:13 -> a\n"
+          + "  4:4:void method2():10:10 -> a\n"
+          + "  5:5:void method2():14 -> a\n";
+
+  @Test
+  public void testNoLine() {
+    Retracer retracer =
+        Retracer.createDefault(
+            ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
+    retraceClassMethodAndPosition(retracer, someClassRenamed, someClassOriginal, 2, 1);
+    retraceClassMethodAndPosition(retracer, someOtherClassRenamed, someOtherClassOriginal, 1, 1);
+  }
+
+  private void retraceClassMethodAndPosition(
+      Retracer retracer,
+      ClassReference renamedClass,
+      ClassReference originalClass,
+      int methodCount,
+      int frameCount) {
+    List<RetraceClassElement> classResult =
+        retracer.retraceClass(renamedClass).stream().collect(Collectors.toList());
+    assertEquals(classResult.size(), 1);
+    RetraceClassElement retraceClassResult = classResult.get(0);
+    assertEquals(originalClass, retraceClassResult.getRetracedClass().getClassReference());
+    RetraceMethodResult retraceMethodResult = retraceClassResult.lookupMethod("a");
+    List<RetraceMethodElement> classMethodResults =
+        retraceMethodResult.stream().collect(Collectors.toList());
+    assertEquals(methodCount, classMethodResults.size());
+    List<RetraceFrameElement> classResultFrames =
+        retraceMethodResult
+            .narrowByPosition(RetraceStackTraceContext.empty(), OptionalInt.of(6))
+            .stream()
+            .collect(Collectors.toList());
+    assertEquals(frameCount, classResultFrames.size());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java b/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
index 3c4c536..db76685 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
@@ -11,6 +11,7 @@
 import static org.objectweb.asm.Opcodes.INVOKESTATIC;
 
 import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.JdkClassFileProvider;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -35,6 +36,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.function.Supplier;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -155,6 +157,7 @@
     return rewrittenR8Jar;
   }
 
+  @Ignore("b/251677184: Failing since update to target 11")
   @Test
   public void testR8RetraceAndComposition() throws Exception {
     Path rewrittenR8Jar = getRewrittenR8Jar();
@@ -244,6 +247,7 @@
     testForR8(Backend.CF)
         .setMode(CompilationMode.RELEASE)
         .addProgramFiles(r8Input)
+        .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
         .addKeepRuleFiles(MAIN_KEEP)
         // TODO(b/241763080): Remove when stable version is default.
         .enableExperimentalMapFileVersion()
@@ -262,6 +266,7 @@
     testForD8(Backend.CF)
         .setMode(CompilationMode.RELEASE)
         .addProgramFiles(r8Input)
+        .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
         .enableExperimentalMapFileVersion()
         // TODO(b/241763080): Enable CF PC test mapping for this compilation.
         .addOptionsModification(
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 d60500f..e4f657f 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
@@ -100,7 +100,7 @@
   @Parameters(name = "{0}, external: {1}, verbose: {2}, stream: {3}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        getTestParameters().withCfRuntimes().build(),
+        getTestParameters().withSystemRuntime().build(),
         BooleanUtils.values(),
         BooleanUtils.values(),
         BooleanUtils.values());
@@ -210,7 +210,7 @@
   }
 
   @Test
-  public void testAmbiguousMissingLine() throws Exception {
+  public void testAmbiguousWithSignatureStackTrace() throws Exception {
     runRetraceTest(new AmbiguousWithSignatureStackTrace());
   }
 
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
index 793a22d..855f0ac 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
@@ -105,7 +105,7 @@
               .retraceFrame(
                   context,
                   OptionalInt.of(27),
-                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
               .stream()
               .collect(Collectors.toList());
       assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
index c037782..2a9ba94 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
@@ -97,7 +97,7 @@
               .retraceFrame(
                   outlineContext,
                   OptionalInt.of(28),
-                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
               .stream()
               .collect(Collectors.toList());
       assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
index 0479f47..0823ff3 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
@@ -102,7 +102,7 @@
               .retraceFrame(
                   context,
                   OptionalInt.of(27),
-                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
               .stream()
               .collect(Collectors.toList());
       assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
index 93611eb..7a8bdee 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
@@ -104,7 +104,7 @@
               .retraceFrame(
                   context,
                   OptionalInt.of(27),
-                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
               .stream()
               .collect(Collectors.toList());
       assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java
deleted file mode 100644
index a3ba721..0000000
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2021, 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.api;
-
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.ProguardMapProducer;
-import com.android.tools.r8.retrace.RetraceClassElement;
-import com.android.tools.r8.retrace.RetraceFrameElement;
-import com.android.tools.r8.retrace.RetraceMethodElement;
-import com.android.tools.r8.retrace.RetraceMethodResult;
-import com.android.tools.r8.retrace.RetraceStackTraceContext;
-import com.android.tools.r8.retrace.Retracer;
-import java.util.List;
-import java.util.OptionalInt;
-import java.util.stream.Collectors;
-import org.junit.Test;
-
-public class RetraceApiOutsideLineRangeTest extends RetraceApiTestBase {
-
-  public RetraceApiOutsideLineRangeTest(TestParameters parameters) {
-    super(parameters);
-  }
-
-  @Override
-  protected Class<? extends RetraceApiBinaryTest> binaryTestClass() {
-    return ApiTest.class;
-  }
-
-  public static class ApiTest implements RetraceApiBinaryTest {
-
-    private final ClassReference someOtherClassOriginal =
-        Reference.classFromTypeName("some.other.Class");
-    private final ClassReference someOtherClassRenamed = Reference.classFromTypeName("a");
-    private final ClassReference someClassOriginal = Reference.classFromTypeName("some.Class");
-    private final ClassReference someClassRenamed = Reference.classFromTypeName("b");
-
-    private final String mapping =
-        someOtherClassOriginal.getTypeName()
-            + " -> "
-            + someOtherClassRenamed.getTypeName()
-            + ":\n"
-            + "  void method1():42:42 -> a\n"
-            + someClassOriginal.getTypeName()
-            + " -> "
-            + someClassRenamed.getTypeName()
-            + ":\n"
-            + "  1:3:void method2():11:13 -> a\n"
-            + "  4:4:void method2():10:10 -> a\n"
-            + "  28:28:void foo.bar.inlinee():92:92 -> a\n"
-            + "  5:5:void method2():14 -> a\n";
-
-    @Test
-    public void testNoLine() {
-      Retracer retracer =
-          Retracer.createDefault(
-              ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
-      retraceClassMethodAndPosition(retracer, someClassRenamed, someClassOriginal, 2, 0);
-      retraceClassMethodAndPosition(retracer, someOtherClassRenamed, someOtherClassOriginal, 1, 1);
-    }
-
-    private void retraceClassMethodAndPosition(
-        Retracer retracer,
-        ClassReference renamedClass,
-        ClassReference originalClass,
-        int methodCount,
-        int frameCount) {
-      List<RetraceClassElement> classResult =
-          retracer.retraceClass(renamedClass).stream().collect(Collectors.toList());
-      assertEquals(classResult.size(), 1);
-      RetraceClassElement retraceClassResult = classResult.get(0);
-      assertEquals(originalClass, retraceClassResult.getRetracedClass().getClassReference());
-      RetraceMethodResult retraceMethodResult = retraceClassResult.lookupMethod("a");
-      List<RetraceMethodElement> classMethodResults =
-          retraceMethodResult.stream().collect(Collectors.toList());
-      assertEquals(methodCount, classMethodResults.size());
-      List<RetraceFrameElement> classResultFrames =
-          retraceMethodResult
-              .narrowByPosition(RetraceStackTraceContext.empty(), OptionalInt.of(6))
-              .stream()
-              .collect(Collectors.toList());
-      assertEquals(frameCount, classResultFrames.size());
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
index 01a62b5..2eb9482 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
@@ -15,7 +15,10 @@
 import com.android.tools.r8.retrace.RetraceFieldElement;
 import com.android.tools.r8.retrace.RetraceMethodElement;
 import com.android.tools.r8.retrace.Retracer;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -39,11 +42,9 @@
         "# { id: 'com.android.tools.r8.mapping', version: 'experimental' }\n"
             + "some.Class -> a:\n"
             + "  some.SuperType field -> a\n"
-            + "  # { id: 'com.android.tools.r8.residualsignature', signature: 'Ljava/lang/Object;'"
-            + " }\n"
+            + "  # { id:'com.android.tools.r8.residualsignature',signature:'Ljava/lang/Object;' }\n"
             + "  some.SubType field -> a\n"
-            + "  # { id: 'com.android.tools.r8.residualsignature', signature: 'Lsome/SuperType;'"
-            + " }\n"
+            + "  # { id:'com.android.tools.r8.residualsignature',signature:'Lsome/SuperType;' }\n"
             + "  void foo(int, int) -> x\n"
             + "  # { id: 'com.android.tools.r8.residualsignature', signature: '(I)V' }\n"
             + "  void foo(int) -> x\n"
@@ -63,31 +64,49 @@
               .collect(Collectors.toList());
       assertEquals(1, fooWithTwoArgs.size());
       assertEquals(
-          "Lsome/Class;foo(II)V",
-          fooWithTwoArgs.get(0).getRetracedMethod().asKnown().getMethodReference().toString());
+          setOf("Lsome/Class;foo(II)V"),
+          fooWithTwoArgs.stream()
+              .map(result -> result.getRetracedMethod().asKnown().getMethodReference().toString())
+              .collect(Collectors.toSet()));
       List<RetraceMethodElement> fooWithOneArg =
           retracer.retraceMethod(Reference.methodFromDescriptor(aClass, "x", "()V")).stream()
               .collect(Collectors.toList());
       assertEquals(1, fooWithOneArg.size());
       assertEquals(
-          "Lsome/Class;foo(I)V",
-          fooWithOneArg.get(0).getRetracedMethod().asKnown().getMethodReference().toString());
+          setOf("Lsome/Class;foo(I)V"),
+          fooWithOneArg.stream()
+              .map(result -> result.getRetracedMethod().asKnown().getMethodReference().toString())
+              .collect(Collectors.toSet()));
       List<RetraceFieldElement> fieldWithSuperType =
           retracer
               .retraceField(
                   Reference.field(aClass, "a", Reference.typeFromTypeName("java.lang.Object")))
               .stream()
               .collect(Collectors.toList());
-      // TODO(b/169953605): Use the residual signature information to prune the result.
-      assertEquals(2, fieldWithSuperType.size());
+      assertEquals(1, fieldWithSuperType.size());
+      assertEquals(
+          setOf("Lsome/Class;field:Lsome/SuperType;"),
+          fieldWithSuperType.stream()
+              .map(result -> result.getField().asKnown().getFieldReference().toString())
+              .collect(Collectors.toSet()));
       List<RetraceFieldElement> fieldWithSubType =
           retracer
               .retraceField(
                   Reference.field(aClass, "a", Reference.typeFromTypeName("some.SuperType")))
               .stream()
               .collect(Collectors.toList());
-      // TODO(b/169953605): Use the residual signature information to prune the result.
-      assertEquals(2, fieldWithSubType.size());
+      assertEquals(1, fieldWithSubType.size());
+      assertEquals(
+          setOf("Lsome/Class;field:Lsome/SubType;"),
+          fieldWithSubType.stream()
+              .map(result -> result.getField().asKnown().getFieldReference().toString())
+              .collect(Collectors.toSet()));
+    }
+
+    private Set<Object> setOf(Object... objects) {
+      Set<Object> result = new HashSet<>();
+      Collections.addAll(result, objects);
+      return result;
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
index 0c1d0a9..40545a6 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
@@ -56,7 +56,7 @@
               .retraceFrame(
                   RetraceStackTraceContext.empty(),
                   OptionalInt.empty(),
-                  Reference.methodFromDescriptor(renamedClass, "a", "()I"))
+                  Reference.methodFromDescriptor(renamedClass, "a", "(I)I"))
               .stream()
               .collect(Collectors.toList()));
       checkResults(
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
index d934a5f..9504609 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
@@ -5,7 +5,7 @@
 package com.android.tools.r8.retrace.api;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.TestParameters;
@@ -49,8 +49,7 @@
               .flatMap(element -> element.lookupField("a").stream())
               .collect(Collectors.toList());
       assertEquals(1, fieldResults.size());
-      // TODO(b/172014416): Should report if synthesized.
-      assertThrows(RuntimeException.class, () -> fieldResults.get(0).isCompilerSynthesized());
+      assertTrue(fieldResults.get(0).isCompilerSynthesized());
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
index 39228e2..08e8bd5 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
@@ -6,7 +6,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.TestParameters;
@@ -52,8 +52,7 @@
       assertEquals(1, methodResults.size());
       RetraceMethodElement retraceMethodElement = methodResults.get(0);
       assertFalse(retraceMethodElement.isUnknown());
-      // TODO(b/172014416): Should report if synthesized.
-      assertThrows(RuntimeException.class, () -> methodResults.get(0).isCompilerSynthesized());
+      assertTrue(methodResults.get(0).isCompilerSynthesized());
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
index 327be4d..5b20d00 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
@@ -32,7 +32,6 @@
           RetraceApiUnknownJsonTest.ApiTest.class,
           RetraceApiRewriteFrameInlineNpeTest.ApiTest.class,
           RetraceApiAmbiguousOriginalRangeTest.ApiTest.class,
-          RetraceApiOutsideLineRangeTest.ApiTest.class,
           RetraceApiRewriteFrameInlineNpeResidualTest.ApiTest.class,
           RetraceApiOutlineNoInlineTest.ApiTest.class,
           RetraceApiOutlineInlineTest.ApiTest.class,
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
index 732c1ce..2f3ec65 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
@@ -140,7 +140,7 @@
               .retraceFrame(
                   context,
                   OptionalInt.of(27),
-                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+                  Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
               .stream()
               .collect(Collectors.toList());
       assertEquals(1, retraceOutlineCallee.size());
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 fa9ca5f..0e340bb 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
@@ -5,7 +5,7 @@
 package com.android.tools.r8.retrace.mappings;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.Reference;
@@ -20,7 +20,6 @@
 
   @Override
   public String mapping() {
-    // TODO(b/169953605): Add enough information to the map to allow precise retracing.
     return StringUtils.lines(
         "foo.bar.Baz -> foo.bar.Baz:", "  java.lang.Object f1 -> a", "  java.lang.String f2 -> a");
   }
@@ -44,13 +43,12 @@
             Reference.classFromTypeName("java.lang.Object"));
 
     RetraceFieldResult result = retracer.retraceField(mappedF1FieldReference);
-    // TODO(b/169829306): Result should not be ambigious.
-    assertTrue(result.isAmbiguous());
+    assertFalse(result.isAmbiguous());
 
     List<FieldReference> retracedFields =
         result.stream()
             .map(f -> f.getField().asKnown().getFieldReference())
             .collect(Collectors.toList());
-    assertEquals(ImmutableList.of(f1FieldReference, f2FieldReference), retracedFields);
+    assertEquals(ImmutableList.of(f1FieldReference), retracedFields);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
index c38c66f..c85fbbe 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
@@ -87,26 +87,26 @@
     ClassSubject mainClass = inspector.clazz(Main.class);
     assertTrue(mainClass.isPresent());
 
-    MethodSubject primitives = mainClass.uniqueMethodWithName("primitives");
+    MethodSubject primitives = mainClass.uniqueMethodWithOriginalName("primitives");
     assertArrayLengthCallCount(primitives, debugMode ? 8 : 0);
 
-    MethodSubject nonNullReferences = mainClass.uniqueMethodWithName("nonNullReferences");
+    MethodSubject nonNullReferences = mainClass.uniqueMethodWithOriginalName("nonNullReferences");
     assertArrayLengthCallCount(nonNullReferences, debugMode ? 3 : 0);
 
     // No assertion on nullReference() because it's seen as always throwing an NPE and
     // the array-length instruction is removed. The output check validates behavior.
 
-    MethodSubject argument = mainClass.uniqueMethodWithName("argument");
+    MethodSubject argument = mainClass.uniqueMethodWithOriginalName("argument");
     assertArrayLengthCallCount(argument, 1);
 
-    MethodSubject phi = mainClass.uniqueMethodWithName("phi");
+    MethodSubject phi = mainClass.uniqueMethodWithOriginalName("phi");
     assertArrayLengthCallCount(phi, 1);
 
     // TODO(139489070): these should be rewritten and result in 0 array-length bytecodes
-    MethodSubject staticConstants = mainClass.uniqueMethodWithName("staticConstants");
+    MethodSubject staticConstants = mainClass.uniqueMethodWithOriginalName("staticConstants");
     assertArrayLengthCallCount(staticConstants, (d8 || debugMode) ? 3 : 0);
 
-    MethodSubject staticNonConstants = mainClass.uniqueMethodWithName("staticNonConstants");
+    MethodSubject staticNonConstants = mainClass.uniqueMethodWithOriginalName("staticNonConstants");
     assertArrayLengthCallCount(staticNonConstants, (d8 || debugMode) ? 2 : 0);
   }
 
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
index c205888..efab8b4 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
@@ -197,13 +197,13 @@
       assertEquals(
           (isR8 ? 0 : 1),
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .filter(InstructionSubject::isStaticPut)
               .count());
       assertFalse(
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .anyMatch(InstructionSubject::isConstNumber));
     } else {
@@ -211,7 +211,7 @@
       // for the class kotlin._Assertions.
       assertFalse(
           subject
-              .uniqueMethodWithName("m")
+              .uniqueMethodWithOriginalName("m")
               .streamInstructions()
               .anyMatch(InstructionSubject::isThrow));
     }
@@ -229,19 +229,19 @@
       assertEquals(
           isR8 ? 1 : 2,
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .filter(InstructionSubject::isStaticPut)
               .count());
       assertTrue(
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .anyMatch(instruction -> instruction.isConstNumber(1)));
     } else {
       assertTrue(
           subject
-              .uniqueMethodWithName("m")
+              .uniqueMethodWithOriginalName("m")
               .streamInstructions()
               .anyMatch(InstructionSubject::isThrow));
     }
@@ -266,18 +266,18 @@
       assertEquals(
           isR8 ? 1 : 2,
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .filter(InstructionSubject::isStaticPut)
               .count());
       assertFalse(
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .anyMatch(InstructionSubject::isConstNumber));
     } else {
       assertThat(subject, isPresent());
-      MethodSubject clinit = subject.uniqueMethodWithName("<clinit>");
+      MethodSubject clinit = subject.uniqueMethodWithOriginalName("<clinit>");
       if (useJvmAssertions) {
         assertTrue(clinit.streamInstructions().anyMatch(InstructionSubject::isStaticPut));
       } else {
@@ -285,7 +285,7 @@
       }
       assertTrue(
           subject
-              .uniqueMethodWithName("m")
+              .uniqueMethodWithOriginalName("m")
               .streamInstructions()
               .anyMatch(InstructionSubject::isThrow));
     }
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
index c9236d4..b677f20 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
@@ -15,16 +15,16 @@
   static void checkAssertionCodeEnabled(ClassSubject subject, String methodName) {
     MatcherAssert.assertThat(subject, Matchers.isPresent());
     // <clinit> is removed by R8.
-    if (subject.uniqueMethodWithName("<clinit>").isPresent()) {
+    if (subject.uniqueMethodWithOriginalName("<clinit>").isPresent()) {
       Assert.assertFalse(
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .anyMatch(InstructionSubject::isStaticPut));
     }
     Assert.assertTrue(
         subject
-            .uniqueMethodWithName(methodName)
+            .uniqueMethodWithOriginalName(methodName)
             .streamInstructions()
             .anyMatch(InstructionSubject::isThrow));
   }
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
index 9ba3328..2141fea 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
@@ -125,16 +125,16 @@
   private void checkAssertionCodeRemoved(ClassSubject subject) {
     assertThat(subject, isPresent());
     // <clinit> is removed by R8 as it becomes empty.
-    if (subject.uniqueMethodWithName("<clinit>").isPresent()) {
+    if (subject.uniqueMethodWithOriginalName("<clinit>").isPresent()) {
       assertFalse(
           subject
-              .uniqueMethodWithName("<clinit>")
+              .uniqueMethodWithOriginalName("<clinit>")
               .streamInstructions()
               .anyMatch(InstructionSubject::isStaticPut));
     }
     assertFalse(
         subject
-            .uniqueMethodWithName("m")
+            .uniqueMethodWithOriginalName("m")
             .streamInstructions()
             .anyMatch(InstructionSubject::isThrow));
   }
@@ -152,12 +152,12 @@
     assertThat(subject, isPresent());
     assertTrue(
         subject
-            .uniqueMethodWithName("<clinit>")
+            .uniqueMethodWithOriginalName("<clinit>")
             .streamInstructions()
             .anyMatch(InstructionSubject::isStaticPut));
     assertTrue(
         subject
-            .uniqueMethodWithName("m")
+            .uniqueMethodWithOriginalName("m")
             .streamInstructions()
             .anyMatch(InstructionSubject::isThrow));
   }
diff --git a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
index 7fc0289..7cd0420 100644
--- a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
@@ -75,29 +75,30 @@
     assertTrue(clazz.isPresent());
 
     if (enableOptimization) {
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("simple"), 1);
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("local"), 1);
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("simple"), 1);
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), 1);
       // Even replaced ordinal is concatenated (and gone).
-      assertOrdinalReplacedAndGone(clazz.uniqueMethodWithName("multipleUsages"));
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("inlined"), 1);
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("inSwitch"), 11);
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("differentTypeStaticField"), 1);
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), 1);
-      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), 1);
+      assertOrdinalReplacedAndGone(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), 1);
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("inSwitch"), 11);
+      assertOrdinalReplacedWithConst(
+          clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), 1);
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), 1);
+      assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonValueStaticField"), 1);
     } else {
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("simple"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("local"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("inSwitch"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
-      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("simple"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("inSwitch"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+      assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
     }
 
-    assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
-    assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+    assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
+    assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
 
-    assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+    assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
   }
 
   @Test
@@ -123,28 +124,29 @@
     assertTrue(clazz.isPresent());
 
     if (enableOptimization) {
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("simple"), "TWO");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("local"), "TWO");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("multipleUsages"), "1TWO");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("inlined"), "TWO");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("differentTypeStaticField"), "DOWN");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), "TWO");
-      assertNameReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), "TWO");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("simple"), "TWO");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), "TWO");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("multipleUsages"), "1TWO");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), "TWO");
+      assertNameReplacedWithConst(
+          clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), "DOWN");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), "TWO");
+      assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonValueStaticField"), "TWO");
     } else {
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("simple"));
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("local"));
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
-      assertNameWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("simple"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+      assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
     }
 
     // TODO(jakew) this should be allowed!
-    assertNameWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
+    assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
 
-    assertNameWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+    assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
 
-    assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+    assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
   }
 
   @Test
@@ -170,33 +172,34 @@
     ClassSubject clazz = inspector.clazz(ToStrings.class);
     assertTrue(clazz.isPresent());
 
-    assertToStringWasNotReplaced(clazz.uniqueMethodWithName("typeToString"));
-    assertToStringReplacedWithConst(clazz.uniqueMethodWithName("valueWithToString"), "one");
-    assertToStringWasNotReplaced(clazz.uniqueMethodWithName("valueWithoutToString"));
+    assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("typeToString"));
+    assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("valueWithToString"), "one");
+    assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("valueWithoutToString"));
 
     if (enableOptimization) {
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("noToString"), "TWO");
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("local"), "TWO");
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("multipleUsages"), "TWO");
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("inlined"), "TWO");
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), "TWO");
+      assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("noToString"), "TWO");
+      assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), "TWO");
+      assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("multipleUsages"), "TWO");
+      assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), "TWO");
       assertToStringReplacedWithConst(
-          clazz.uniqueMethodWithName("differentTypeStaticField"), "DOWN");
-      assertToStringReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), "TWO");
+          clazz.uniqueMethodWithOriginalName("nonValueStaticField"), "TWO");
+      assertToStringReplacedWithConst(
+          clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), "DOWN");
+      assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), "TWO");
     } else {
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("noToString"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("local"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("nonValueStaticField"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
-      assertToStringWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("noToString"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonValueStaticField"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+      assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
     }
 
-    assertToStringWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
-    assertToStringWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+    assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
+    assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
 
-    assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+    assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
   }
 
   private static void assertOrdinalReplacedWithConst(MethodSubject method, int expectedConst) {
diff --git a/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java b/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
index 26dcb7a..ddbefce 100644
--- a/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
@@ -67,16 +67,16 @@
 
   public void checkSwitchKeys(CodeInspector inspector) {
     checkSwitch(
-        inspector.clazz(TestClass.class).uniqueMethodWithName("f"),
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("f"),
         parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
     checkSwitch(
-        inspector.clazz(TestClass.class).uniqueMethodWithName("g"),
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("g"),
         parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
     // Debug mode will not rewrite switch statements except when the MAX_INT key is present.
     assertEquals(
         inspector
             .clazz(TestClass.class)
-            .uniqueMethodWithName("h")
+            .uniqueMethodWithOriginalName("h")
             .streamInstructions()
             .filter(InstructionSubject::isSwitch)
             .count(),
@@ -85,7 +85,7 @@
                 && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K)));
 
     checkStringSwitch(
-        inspector.clazz(TestClass.class).uniqueMethodWithName("s"),
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("s"),
         parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
index 0fce1c4..201971d 100644
--- a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
@@ -55,7 +55,7 @@
     assertFalse(classSubject.isAbstract());
 
     // A.m() is also not made abstract in compat mode.
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("m");
     assertThat(methodSubject, isPresent());
     assertFalse(methodSubject.isAbstract());
 
@@ -86,7 +86,7 @@
     assertTrue(classSubject.isAbstract());
 
     // A.m() is also made abstract in full mode.
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("m");
     assertThat(methodSubject, isPresent());
     assertTrue(methodSubject.isAbstract());
 
diff --git a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
index cb750b5..ca0f8d5 100644
--- a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
@@ -55,7 +55,7 @@
     ClassSubject classSubject = inspector.clazz(C.class);
     assertThat(classSubject, isPresent());
     // TODO(b/150445487): Member rebinding will rewrite B::foo to A::foo causing C::foo to remain.
-    assertThat(classSubject.uniqueMethodWithName("foo"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), isPresent());
   }
 
   @NoVerticalClassMerging
diff --git a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
index 5fec641..7ccba55 100644
--- a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
@@ -161,7 +161,8 @@
         .compile()
         .inspect(
             inspector ->
-                assertThat(inspector.clazz(main.name).uniqueFieldWithName("sField"), isAbsent()));
+                assertThat(
+                    inspector.clazz(main.name).uniqueFieldWithOriginalName("sField"), isAbsent()));
   }
 
   @Test
@@ -196,7 +197,7 @@
           assertThat(emptyClassSubject, isPresent());
           assertTrue(emptyClassSubject.allFields().isEmpty());
 
-          MethodSubject fooMethodSubject = emptyClassSubject.uniqueMethodWithName("foo");
+          MethodSubject fooMethodSubject = emptyClassSubject.uniqueMethodWithOriginalName("foo");
           assertThat(fooMethodSubject, isPresent());
           assertTrue(
               fooMethodSubject
@@ -350,7 +351,7 @@
       ClassBuilder fieldHolder,
       String fieldName,
       boolean isR8) {
-    FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithName(fieldName);
+    FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithOriginalName(fieldName);
     if (isR8) {
       assertThat(fld, isPresentAndRenamed());
     } else {
@@ -359,7 +360,7 @@
 
     ClassSubject classSubject = inspector.clazz(className);
     assertThat(classSubject, isPresent());
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+    MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
     assertThat(methodSubject, isPresent());
     Iterator<InstructionSubject> it =
         methodSubject.iterateInstructions(InstructionSubject::isFieldAccess);
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java b/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
index 5a16cf6..a47a068 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
@@ -70,7 +70,7 @@
     assertThat(inspector.clazz(ABSENT_ANNOTATION), not(isPresent()));
     assertThat(inspector.clazz(PRESENT_ANNOTATION), isPresent());
     ClassSubject clazz = inspector.clazz(CLASS_WITH_ANNOTATED_METHOD);
-    MethodSubject method = clazz.uniqueMethodWithName(ANNOTATED_METHOD);
+    MethodSubject method = clazz.uniqueMethodWithOriginalName(ANNOTATED_METHOD);
     assertThat(method, isPresent());
   }
 
@@ -125,7 +125,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(CLASS_WITH_ANNOTATED_METHOD);
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName(ANNOTATED_METHOD), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName(ANNOTATED_METHOD), isPresent());
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
index 05cec26..87ef2b8 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
@@ -46,7 +46,8 @@
         .compile()
         .inspect(
             inspector ->
-                assertThat(inspector.clazz(Foo.class).uniqueFieldWithName("value"), isPresent()))
+                assertThat(
+                    inspector.clazz(Foo.class).uniqueFieldWithOriginalName("value"), isPresent()))
         .run(parameters.getRuntime(), Foo.class)
         .assertSuccessWithEmptyOutput();
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java b/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
index a1f492b..3f24aed 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
@@ -57,7 +57,7 @@
             inspector -> {
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
-              assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
+              assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
               assertEquals(1, aClassSubject.allMethods().size());
             });
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
index 2b2e440..a5704cb 100644
--- a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
@@ -55,7 +55,7 @@
   private void checkIsFooPresent(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(C.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithName("foo"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
   }
 
   @NoVerticalClassMerging
diff --git a/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
index e38943c..0a61b39 100644
--- a/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
@@ -147,7 +147,7 @@
     } else {
       assertThat(superInterface1, isPresentAndRenamed());
     }
-    MethodSubject foo = superInterface1.uniqueMethodWithName("foo");
+    MethodSubject foo = superInterface1.uniqueMethodWithOriginalName("foo");
     assertThat(foo, not(isPresent()));
     ClassSubject superInterface2 = inspector.clazz(B112452064SuperInterface2.class);
     if (enableVerticalClassMerging) {
@@ -155,7 +155,7 @@
     } else {
       assertThat(superInterface2, isPresentAndRenamed());
     }
-    MethodSubject bar = superInterface2.uniqueMethodWithName("bar");
+    MethodSubject bar = superInterface2.uniqueMethodWithOriginalName("bar");
     assertThat(bar, not(isPresent()));
     ClassSubject subInterface = inspector.clazz(B112452064SubInterface.class);
     if (enableUnusedInterfaceRemoval) {
diff --git a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
index 74b7c8a..a5c58ae 100644
--- a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
@@ -78,7 +78,8 @@
                         .anyMatch(
                             c -> {
                               if (c.isSynthesizedJavaLambdaClass()) {
-                                assertThat(c.uniqueMethodWithName("computeTheFoo"), isPresent());
+                                assertThat(
+                                    c.uniqueMethodWithOriginalName("computeTheFoo"), isPresent());
                                 return true;
                               }
                               return false;
diff --git a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
index 3fc3434..9dd9eb6 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
@@ -8,9 +8,11 @@
 import static org.hamcrest.core.StringContains.containsString;
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.JdkClassFileProvider;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -35,7 +37,7 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withCfRuntimes().build();
+    return getTestParameters().withSystemRuntime().build();
   }
 
   public PrintConfigurationTest(TestParameters parameters) {
@@ -83,8 +85,10 @@
             "-printconfiguration proguard-config-out.txt");
     FileUtils.writeTextFile(proguardConfigFile, proguardConfig.trim());
 
+    assertEquals(TestRuntime.getSystemRuntime(), parameters.getRuntime());
     testForExternalR8(Backend.DEX, parameters.getRuntime())
         .addProgramClasses(PrintConfigurationTestClass.class)
+        .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
         .addKeepRuleFiles(proguardConfigFile)
         .compile();
 
diff --git a/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java b/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
index 27c98f6..7149490 100644
--- a/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
@@ -55,7 +55,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(B.class);
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName("foo"), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName("foo"), isPresent());
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
index 3cf998b..f12c211 100644
--- a/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
@@ -50,7 +50,7 @@
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject.init(), not(isPresent()));
     // TODO(b/132669230): A.method() should be pruned.
-    assertThat(classSubject.uniqueMethodWithName("method"), isPresent());
+    assertThat(classSubject.uniqueMethodWithOriginalName("method"), isPresent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
index ac46b3f..2fc2284 100644
--- a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
@@ -167,10 +167,10 @@
 
     ClassSubject testClass = inspector.clazz(TestClass.class);
     assertThat(testClass, isPresent());
-    MethodSubject foo = testClass.uniqueMethodWithName("foo");
+    MethodSubject foo = testClass.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresent());
     assertTrue(hasThrow(foo));
-    MethodSubject bar = testClass.uniqueMethodWithName("bar");
+    MethodSubject bar = testClass.uniqueMethodWithOriginalName("bar");
     assertThat(bar, isPresent());
     assertTrue(hasThrow(bar));
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
index abb4c9f..2217ace 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -90,14 +90,14 @@
               ClassSubject bClass = inspector.clazz(B.class);
               // The class constants will force A and B to be retained, but not the methods.
               assertThat(bClass, isPresentAndRenamed());
-              assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
-              assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
 
               assertThat(aClass, isPresentAndRenamed());
               // The dependent rule with soft-pinning of bar never causes A::bar to be retained
               // regardless of A and A::foo being retained.
-              assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
-              MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+              assertThat(aClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
+              MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
               if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
index 5c99afd..4beb2fe 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -77,7 +77,8 @@
               assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
 
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
-              MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+              MethodSubject getMethodSubject =
+                  companionClassSubject.uniqueMethodWithOriginalName("get");
 
               if (allowOptimization) {
                 assertTrue(
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
index e6e8b69..4bd9bfd 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
@@ -93,8 +93,8 @@
               // The class constants will force A and B to be retained, but not the foo methods.
               assertThat(bClass, isPresentAndRenamed(allowObfuscation));
               assertThat(aClass, isPresentAndRenamed(allowObfuscation));
-              assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
-              MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+              assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+              MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
               if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
index 44abb34..905951a 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
@@ -62,8 +62,9 @@
               assertThat(inspector.clazz(TestClass.class), isPresent());
 
               ClassSubject softPinnedClass = inspector.clazz(SoftPinned.class);
-              assertThat(softPinnedClass.uniqueMethodWithName("used"), isPresentAndNotRenamed());
-              assertThat(softPinnedClass.uniqueMethodWithName("unused"), not(isPresent()));
+              assertThat(
+                  softPinnedClass.uniqueMethodWithOriginalName("used"), isPresentAndNotRenamed());
+              assertThat(softPinnedClass.uniqueMethodWithOriginalName("unused"), not(isPresent()));
 
               // SoftPinned.used(A) remains thus A must be present and not renamed.
               assertThat(inspector.clazz(A.class), isPresentAndNotRenamed());
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
index e0e151a..0d73c09 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
@@ -90,10 +90,10 @@
               assertThat(aClass, isPresentAndRenamed());
               assertThat(bClass, isPresentAndRenamed());
 
-              FieldSubject aFoo = aClass.uniqueFieldWithName("foo");
-              FieldSubject aBar = aClass.uniqueFieldWithName("bar");
-              FieldSubject bFoo = bClass.uniqueFieldWithName("foo");
-              FieldSubject bBar = bClass.uniqueFieldWithName("bar");
+              FieldSubject aFoo = aClass.uniqueFieldWithOriginalName("foo");
+              FieldSubject aBar = aClass.uniqueFieldWithOriginalName("bar");
+              FieldSubject bFoo = bClass.uniqueFieldWithOriginalName("foo");
+              FieldSubject bBar = bClass.uniqueFieldWithOriginalName("bar");
 
               if (allowOptimization) {
                 // PG fails to optimize out the referenced field.
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
index 5305ced..ff2da06 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -92,14 +92,14 @@
               ClassSubject bClass = inspector.clazz(B.class);
               // The class constants will force A and B to be retained, but not the methods.
               assertThat(bClass, isPresentAndRenamed());
-              assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
-              assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+              assertThat(bClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
 
               assertThat(aClass, isPresentAndRenamed());
               // The dependent rule with soft-pinning of bar never causes A::bar to be retained
               // regardless of A and A::foo being retained.
-              assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
-              MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+              assertThat(aClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
+              MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
               if (allowOptimization) {
                 assertThat(aFoo, not(isPresent()));
               } else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
index 4266e57..4d62baf 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
@@ -54,7 +54,8 @@
         .inspect(
             inspector ->
                 assertThat(
-                    inspector.clazz(TestClass.class).uniqueMethodWithName("test"), isPresent()))
+                    inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("test"),
+                    isPresent()))
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutputLines("foo");
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
index 2322f85..6f8cf2a 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
@@ -74,7 +74,7 @@
 
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
               ClassSubject companionClassSubject = inspector.clazz(Companion.class);
-              FieldSubject xFieldSubject = companionClassSubject.uniqueFieldWithName("x");
+              FieldSubject xFieldSubject = companionClassSubject.uniqueFieldWithOriginalName("x");
 
               // PG fails to optimize fields regardless of keep flags.
               if (allowOptimization && shrinker.isR8()) {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
index 9dbdbb4..043e0e9 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -75,7 +75,8 @@
               assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
 
               MethodSubject mainMethodSubject = testClassSubject.mainMethod();
-              MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+              MethodSubject getMethodSubject =
+                  companionClassSubject.uniqueMethodWithOriginalName("get");
 
               if (allowOptimization) {
                 assertTrue(
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
index 55556b4..2f5eab9 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
@@ -63,12 +63,12 @@
               assertThat(clazz, isPresent());
               assertThat(clazz, isPresentAndRenamed());
 
-              FieldSubject field = clazz.uniqueFieldWithName("field");
+              FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
               assertThat(field, isPresent());
               assertThat(field.annotation(FieldAnnotation.class.getTypeName()), isPresent());
               assertThat(inspector.clazz(FieldAnnotationUse.class), isPresentAndRenamed());
 
-              FieldSubject staticField = clazz.uniqueFieldWithName("staticField");
+              FieldSubject staticField = clazz.uniqueFieldWithOriginalName("staticField");
               assertThat(staticField, isPresent());
               assertThat(
                   staticField.annotation(StaticFieldAnnotation.class.getTypeName()), isPresent());
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
index 62bcf76..d07689d 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
@@ -64,13 +64,14 @@
 
               // The annotation on getNonNull() is kept meanwhile it is subject to other
               // optimizations.
-              MethodSubject getNonNullSubject = classSubject.uniqueMethodWithName("getNonNull");
+              MethodSubject getNonNullSubject =
+                  classSubject.uniqueMethodWithOriginalName("getNonNull");
               assertThat(getNonNullSubject, isPresentAndRenamed());
               assertThat(getNonNullSubject.annotation(NeverInline.class), isPresent());
 
               // Check that the code has been optimized using the fact that getNonNull() returns a
               // non-null value.
-              assertThat(classSubject.uniqueMethodWithName("dead"), isAbsent());
+              assertThat(classSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
               assertThat(classSubject.mainMethod(), not(containsThrow()));
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
index e78d675..135287e 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
@@ -125,7 +125,7 @@
               ClassSubject clazz = inspector.clazz(Foo.class);
               assertThat(clazz, isPresent());
               assertThat(clazz.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
-              MethodSubject foo = clazz.uniqueMethodWithName("foo");
+              MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
               assertThat(foo, isPresent());
               assertThat(foo.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
               assertFalse(foo.getMethod().parameterAnnotationsList.isEmpty());
@@ -139,7 +139,7 @@
                       .toSourceString());
               assertThat(
                   clazz
-                      .uniqueFieldWithName("bar")
+                      .uniqueFieldWithOriginalName("bar")
                       .annotation(LibraryAnnotation.class.getTypeName()),
                   isPresent());
             })
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
index da0b781..6aeec9f 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
@@ -77,14 +77,14 @@
     assertThat(testClassSubject, isPresent());
 
     MethodSubject methodWithLiveProgramAnnotationSubject =
-        testClassSubject.uniqueMethodWithName("methodWithLiveProgramAnnotation");
+        testClassSubject.uniqueMethodWithOriginalName("methodWithLiveProgramAnnotation");
     assertThat(methodWithLiveProgramAnnotationSubject, isPresent());
     assertEquals(
         BooleanUtils.intValue(enableCompatMode),
         methodWithLiveProgramAnnotationSubject.getMethod().annotations().size());
 
     MethodSubject methodWithDeadProgramAnnotationSubject =
-        testClassSubject.uniqueMethodWithName("methodWithDeadProgramAnnotation");
+        testClassSubject.uniqueMethodWithOriginalName("methodWithDeadProgramAnnotation");
     assertThat(methodWithDeadProgramAnnotationSubject, isPresent());
     assertEquals(0, methodWithDeadProgramAnnotationSubject.getMethod().annotations().size());
 
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 852c86f..d0c5bdc 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -113,13 +113,13 @@
             .inspector();
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresentAndNotRenamed());
-    MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+    MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
     assertThat(f1, isPresentAndNotRenamed());
-    MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+    MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
     assertThat(f2, isPresentAndNotRenamed());
-    MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+    MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
     assertThat(f3, isPresentAndNotRenamed());
-    MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+    MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
     assertThat(f4, isPresentAndNotRenamed());
 
     ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -155,13 +155,13 @@
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
-    MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+    MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
     assertThat(f1, isPresentAndNotRenamed());
-    MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+    MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
     assertThat(f2, isPresentAndNotRenamed());
-    MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+    MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
     assertThat(f3, not(isPresent()));
-    MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+    MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
     assertThat(f4, not(isPresent()));
 
     ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -193,13 +193,13 @@
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
-    MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+    MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
     assertThat(f1, isPresentAndNotRenamed());
-    MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+    MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
     assertThat(f2, isPresentAndNotRenamed());
-    MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+    MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
     assertThat(f3, not(isPresent()));
-    MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+    MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
     assertThat(f4, not(isPresent()));
 
     ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -230,13 +230,13 @@
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
-    MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+    MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
     assertThat(f1, isPresent());
-    MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+    MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
     assertThat(f2, isPresent());
-    MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+    MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
     assertThat(f3, not(isPresent()));
-    MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+    MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
     assertThat(f4, not(isPresent()));
 
     ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
index 7d2173f..683a18c 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
@@ -120,7 +120,7 @@
             EXPECTED_DEFAULT_VALUE_ANNOTATION, EXPECTED_SERIALIZED_ANNOTATION)
         .inspect(
             codeInspector -> {
-              FieldSubject bar = codeInspector.clazz(Foo.class).uniqueFieldWithName("bar");
+              FieldSubject bar = codeInspector.clazz(Foo.class).uniqueFieldWithOriginalName("bar");
               AnnotationSubject annotation = bar.annotation(SerializedName.class.getTypeName());
               assertThat(annotation, isPresent());
               assertEquals(0, annotation.getAnnotation().elements.length);
diff --git a/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java b/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
index a4ba893..ff7cb9e 100644
--- a/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
@@ -42,15 +42,15 @@
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
 
-    MethodSubject nonNull = main.uniqueMethodWithName("clearlyNonNull");
+    MethodSubject nonNull = main.uniqueMethodWithOriginalName("clearlyNonNull");
     assertThat(nonNull, isPresent());
     assertEquals(0, countArrayLength(nonNull));
 
-    MethodSubject nullable = main.uniqueMethodWithName("isNullable");
+    MethodSubject nullable = main.uniqueMethodWithOriginalName("isNullable");
     assertThat(nullable, isPresent());
     assertEquals(isR8 ? 0 : 1, countArrayLength(nullable));
 
-    MethodSubject nullCheck = main.uniqueMethodWithName("afterNullCheck");
+    MethodSubject nullCheck = main.uniqueMethodWithOriginalName("afterNullCheck");
     assertThat(nullCheck, isPresent());
     assertEquals(isR8 ? 0 : 1, countArrayLength(nullCheck));
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
index fed4e6d..6419f78 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
@@ -55,11 +55,14 @@
     ClassSubject testClassSubject = inspector.clazz(TestClass.class);
     assertThat(testClassSubject, isPresent());
 
-    inspectMethod(testClassSubject.uniqueMethodWithName("testModelingOfSideEffects"), false, false);
     inspectMethod(
-        testClassSubject.uniqueMethodWithName("testModelingOfSideEffectsMaybeNull"), true, false);
+        testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffects"), false, false);
     inspectMethod(
-        testClassSubject.uniqueMethodWithName("testModelingOfSideEffectsMaybeSubclass"),
+        testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffectsMaybeNull"),
+        true,
+        false);
+    inspectMethod(
+        testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffectsMaybeSubclass"),
         false,
         true);
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
index ad79ff7..0cabc92 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
@@ -69,7 +69,7 @@
         mainMethod.streamInstructions().noneMatch(
             i -> i.isInvoke() && i.getMethod().name.toString().equals("debug")));
 
-    MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+    MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
     assertThat(testInvokeInterface, not(isPresent()));
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
index 41311d2..3fd3987 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
@@ -68,10 +68,10 @@
           mainMethod.streamInstructions().noneMatch(
               i -> i.isInvoke() && i.getMethod().name.toString().equals("info")));
 
-      MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+      MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
       assertThat(testInvokeInterface, not(isPresent()));
 
-      FieldSubject tag = main.uniqueFieldWithName("TAG");
+      FieldSubject tag = main.uniqueFieldWithOriginalName("TAG");
       assertThat(tag, not(isPresent()));
     }
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
index 352a53c..78f813d 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
@@ -84,7 +84,7 @@
   private void verifyDebugMethodIsRemoved(CodeInspector inspector) {
     ClassSubject main = inspector.clazz(MAIN);
     assertThat(main, isPresent());
-    MethodSubject debug = main.uniqueMethodWithName("debug");
+    MethodSubject debug = main.uniqueMethodWithOriginalName("debug");
     assertThat(debug, not(isPresent()));
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
index 0caf415..31930b0 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
@@ -49,7 +49,7 @@
               ClassSubject mainClassSubject = inspector.clazz(Main.class);
               assertThat(mainClassSubject, isPresent());
 
-              MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithName("get");
+              MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("get");
               assertThat(getMethodSubject, isAbsent());
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
index a6d7d67..4455ff1 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
@@ -128,7 +128,7 @@
           mainMethod.streamInstructions().noneMatch(
               i -> i.isInvoke() && i.getMethod().name.toString().equals("m")));
 
-      MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+      MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
       assertThat(testInvokeInterface, isPresent());
       // With call site optimizations, the dynamic type of the argument is accurate (Impl1),
       // hence the accurate resolution of the method call, resulting in rule application.
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
index 81d33fc..4509531 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
@@ -78,7 +78,7 @@
     assertTrue(mainMethod.streamInstructions()
         .noneMatch(i -> i.isIf() || i.isIfEqz() || i.isIfNez()));
 
-    FieldSubject hasR8 = main.uniqueFieldWithName("HAS_R8");
+    FieldSubject hasR8 = main.uniqueFieldWithOriginalName("HAS_R8");
     assertThat(hasR8, not(isPresent()));
 
     MethodSubject clinit = main.clinit();
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
index ce5e0fe..ee49eb3 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
@@ -230,13 +230,13 @@
   private void compatCodePresent(CodeInspector inspector) {
     ClassSubject compatLibrary = inspector.clazz(compatLibraryClassName);
     assertThat(compatLibrary, isPresent());
-    assertThat(compatLibrary.uniqueMethodWithName("compatMethod"), isPresent());
+    assertThat(compatLibrary.uniqueMethodWithOriginalName("compatMethod"), isPresent());
   }
 
   private void compatCodeNotPresent(CodeInspector inspector) {
     ClassSubject compatLibrary = inspector.clazz(compatLibraryClassName);
     assertThat(compatLibrary, isPresent());
-    assertThat(compatLibrary.uniqueMethodWithName("compatMethod"), not(isPresent()));
+    assertThat(compatLibrary.uniqueMethodWithOriginalName("compatMethod"), not(isPresent()));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
index 5c7a755..f37d00a 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
@@ -69,9 +69,9 @@
   private void inspect(CodeInspector inspector) {
     ClassSubject clazz = inspector.clazz(Main.class);
     assertTrue(clazz.getDexProgramClass().annotations().isEmpty());
-    MethodSubject main = clazz.uniqueMethodWithName("main");
+    MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
     assertTrue(main.getMethod().annotations().isEmpty());
-    FieldSubject field = clazz.uniqueFieldWithName("field");
+    FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
     assertTrue(field.getField().annotations().isEmpty());
     assertTrue(
         clazz.getDexProgramClass().sourceFile == null
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
index 84b88e6..2d2160b 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
@@ -96,17 +96,18 @@
     assertThat(keptClass, isPresent());
     assertEquals(
         "<T:Ljava/lang/Object;>Ljava/lang/Object;", keptClass.getFinalSignatureAttribute());
-    FieldSubject keptField = keptClass.uniqueFieldWithName("keptField");
+    FieldSubject keptField = keptClass.uniqueFieldWithOriginalName("keptField");
     assertThat(keptField, isPresent());
     assertEquals("TT;", keptField.getFinalSignatureAttribute());
-    MethodSubject keptMethod = keptClass.uniqueMethodWithName("keptMethod");
+    MethodSubject keptMethod = keptClass.uniqueMethodWithOriginalName("keptMethod");
     assertThat(keptMethod, isPresent());
     assertEquals("<R:Ljava/lang/Object;>(TT;)TR;", keptMethod.getFinalSignatureAttribute());
 
     // For all remaining classes and members, we should only keep signatures if in compat mode.
-    checkMemberSignature(keptClass.uniqueFieldWithName("notKeptField"), keepForNotKept, "TT;");
     checkMemberSignature(
-        keptClass.uniqueMethodWithName("notKeptMethod"),
+        keptClass.uniqueFieldWithOriginalName("notKeptField"), keepForNotKept, "TT;");
+    checkMemberSignature(
+        keptClass.uniqueMethodWithOriginalName("notKeptMethod"),
         keepForNotKept,
         "<R:Ljava/lang/Object;>(TT;)TR;");
 
@@ -119,9 +120,11 @@
       assertNull(notKeptClass.getFinalSignatureAttribute());
     }
     checkMemberSignature(
-        notKeptClass.uniqueFieldWithName("notKeptField"), keepForNotKept, "Ljava/util/List<TP;>;");
+        notKeptClass.uniqueFieldWithOriginalName("notKeptField"),
+        keepForNotKept,
+        "Ljava/util/List<TP;>;");
     checkMemberSignature(
-        notKeptClass.uniqueMethodWithName("notKeptMethod"),
+        notKeptClass.uniqueMethodWithOriginalName("notKeptMethod"),
         keepForNotKept,
         "(TP;TP;)Ljava/util/List<TP;>;");
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java b/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
index 27f7735..5b2bd38 100644
--- a/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
@@ -76,9 +76,11 @@
                       .count());
 
               assertThat(
-                  mainClassSubject.uniqueMethodWithName("requireNonNullWithoutReturn"), isAbsent());
+                  mainClassSubject.uniqueMethodWithOriginalName("requireNonNullWithoutReturn"),
+                  isAbsent());
               assertThat(
-                  mainClassSubject.uniqueMethodWithName("requireNonNullWithReturn"), isAbsent());
+                  mainClassSubject.uniqueMethodWithOriginalName("requireNonNullWithReturn"),
+                  isAbsent());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutput(getExpectedOutput());
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
index 14c99ba..620c73d 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
@@ -172,64 +172,72 @@
     assertThat(superIfaceSubject, isPresent());
     if (interfaceMethodsKept) {
       assertEquals(
-          expected.contains("m1"), superIfaceSubject.uniqueMethodWithName("m1").isPresent());
+          expected.contains("m1"),
+          superIfaceSubject.uniqueMethodWithOriginalName("m1").isPresent());
       if (expected.contains("m1")) {
-        assertThat(superIfaceSubject.uniqueMethodWithName("m1"), isAbstract());
+        assertThat(superIfaceSubject.uniqueMethodWithOriginalName("m1"), isAbstract());
       }
     }
     ClassSubject subIfaceSubject = inspector.clazz(SubIface.class);
     assertThat(subIfaceSubject, isPresent());
     if (interfaceMethodsKept) {
-      assertEquals(expected.contains("m2"), subIfaceSubject.uniqueMethodWithName("m2").isPresent());
+      assertEquals(
+          expected.contains("m2"), subIfaceSubject.uniqueMethodWithOriginalName("m2").isPresent());
       if (expected.contains("m2")) {
-        assertThat(subIfaceSubject.uniqueMethodWithName("m2"), isAbstract());
+        assertThat(subIfaceSubject.uniqueMethodWithOriginalName("m2"), isAbstract());
       }
     }
     ClassSubject subSubIfaceSubject = inspector.clazz(SubSubIface.class);
     assertThat(subSubIfaceSubject, isPresent());
     if (interfaceMethodsKept) {
       assertEquals(
-          expected.contains("m3"), subSubIfaceSubject.uniqueMethodWithName("m3").isPresent());
+          expected.contains("m3"),
+          subSubIfaceSubject.uniqueMethodWithOriginalName("m3").isPresent());
       if (expected.contains("m3")) {
-        assertThat(subSubIfaceSubject.uniqueMethodWithName("m3"), isAbstract());
+        assertThat(subSubIfaceSubject.uniqueMethodWithOriginalName("m3"), isAbstract());
       }
     }
     ClassSubject implSubject = inspector.clazz(Impl.class);
     assertThat(implSubject, isPresent());
     if (interfaceMethodsKept) {
-      assertEquals(expected.contains("m1"), implSubject.uniqueMethodWithName("m1").isPresent());
-      assertEquals(expected.contains("m2"), implSubject.uniqueMethodWithName("m2").isPresent());
-      assertEquals(expected.contains("m3"), implSubject.uniqueMethodWithName("m3").isPresent());
+      assertEquals(
+          expected.contains("m1"), implSubject.uniqueMethodWithOriginalName("m1").isPresent());
+      assertEquals(
+          expected.contains("m2"), implSubject.uniqueMethodWithOriginalName("m2").isPresent());
+      assertEquals(
+          expected.contains("m3"), implSubject.uniqueMethodWithOriginalName("m3").isPresent());
     }
-    assertEquals(expected.contains("m4"), implSubject.uniqueMethodWithName("m4").isPresent());
+    assertEquals(
+        expected.contains("m4"), implSubject.uniqueMethodWithOriginalName("m4").isPresent());
     ClassSubject subImplSubject = inspector.clazz(SubImpl.class);
     assertThat(subImplSubject, isPresent());
-    assertThat(subImplSubject.uniqueMethodWithName("m1"), not(isPresent()));
-    assertThat(subImplSubject.uniqueMethodWithName("m2"), not(isPresent()));
-    assertThat(subImplSubject.uniqueMethodWithName("m3"), not(isPresent()));
-    assertThat(subImplSubject.uniqueMethodWithName("m4"), not(isPresent()));
-    assertEquals(expected.contains("m5"), subImplSubject.uniqueMethodWithName("m5").isPresent());
+    assertThat(subImplSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+    assertThat(subImplSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
+    assertThat(subImplSubject.uniqueMethodWithOriginalName("m3"), not(isPresent()));
+    assertThat(subImplSubject.uniqueMethodWithOriginalName("m4"), not(isPresent()));
+    assertEquals(
+        expected.contains("m5"), subImplSubject.uniqueMethodWithOriginalName("m5").isPresent());
     ClassSubject subSubImplSubject = inspector.clazz(SubSubImpl.class);
     assertThat(subSubImplSubject, isPresent());
     // FOO
     assertEquals(
         subSubImplExpected.contains("m1"),
-        subSubImplSubject.uniqueMethodWithName("m1").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m1").isPresent());
     assertEquals(
         subSubImplExpected.contains("m2"),
-        subSubImplSubject.uniqueMethodWithName("m2").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m2").isPresent());
     assertEquals(
         subSubImplExpected.contains("m3"),
-        subSubImplSubject.uniqueMethodWithName("m3").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m3").isPresent());
     assertEquals(
         subSubImplExpected.contains("m4"),
-        subSubImplSubject.uniqueMethodWithName("m4").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m4").isPresent());
     assertEquals(
         subSubImplExpected.contains("m5"),
-        subSubImplSubject.uniqueMethodWithName("m5").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m5").isPresent());
     assertEquals(
         subSubImplExpected.contains("m6"),
-        subSubImplSubject.uniqueMethodWithName("m6").isPresent());
+        subSubImplSubject.uniqueMethodWithOriginalName("m6").isPresent());
   }
 
   private void checkAllMethodsInterfacesKept(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
index 265e46a..e1fab88 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
@@ -52,7 +52,7 @@
   private void inspect(CodeInspector codeInspector) {
     ClassSubject c = codeInspector.clazz(C.class);
     assertThat(c, isPresent());
-    MethodSubject m = c.uniqueMethodWithName("m");
+    MethodSubject m = c.uniqueMethodWithOriginalName("m");
     assertThat(m, isPresent());
     assertTrue(m.getMethod().hasCode());
     // TODO(b/124017330): Verify that I$-CC.m() has been inlined into C.m().
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
index 42bda91..8e63f60 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
@@ -67,13 +67,13 @@
                 inspector -> {
                   assertThat(inspector.clazz(Enum.class), isPresentAndRenamed());
                   assertThat(
-                      inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+                      inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
                       isPresentAndNotRenamed());
                   assertThat(
-                      inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+                      inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
                       isPresentAndNotRenamed());
                   assertThat(
-                      inspector.clazz(Enum.class).uniqueFieldWithName("TEST_THREE"),
+                      inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_THREE"),
                       isPresentAndRenamed());
                   minifiedEnumName.set(inspector.clazz(Enum.class).getFinalName());
                 })
@@ -114,13 +114,13 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_THREE"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_THREE"),
                   useGenericEnumsRule ? isPresentAndRenamed() : isPresentAndNotRenamed());
             })
         .assertSuccessWithOutput(EXPECTED_RESULT);
@@ -139,10 +139,10 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_ONE"),
+                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_ONE"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
               assertThat(
-                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_TWO"),
+                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_TWO"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
             })
         .assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
index 5de0ff2..92e2c31 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
@@ -66,10 +66,10 @@
                 inspector -> {
                   assertThat(inspector.clazz(Enum.class), isPresentAndRenamed());
                   assertThat(
-                      inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+                      inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
                       isPresentAndNotRenamed());
                   assertThat(
-                      inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+                      inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
                       isPresentAndRenamed());
                   minifiedEnumName.set(inspector.clazz(Enum.class).getFinalName());
                 })
@@ -111,10 +111,10 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
                   useGenericEnumsRule ? isPresentAndRenamed() : isPresentAndNotRenamed());
             })
         .assertSuccessWithOutput(EXPECTED_RESULT);
@@ -133,7 +133,7 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_ONE"),
+                  inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_ONE"),
                   parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
             })
         .assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
index bc2e7ac..f769adb 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
@@ -47,9 +47,10 @@
         .inspect(
             inspector -> {
               assertThat(
-                  inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
                   isPresentAndRenamed());
-              assertThat(inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"), isAbsent());
+              assertThat(
+                  inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"), isAbsent());
             })
         .assertSuccessWithOutput(EXPECTED_RESULT);
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
index eab4bff..7cf7921 100644
--- a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
+++ b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
@@ -52,7 +52,7 @@
 
   private static void shaking13EnsureFieldWritesCorrect(CodeInspector inspector) {
     ClassSubject mainClass = inspector.clazz("shaking13.Shaking");
-    MethodSubject testMethod = mainClass.uniqueMethodWithName("fieldTest");
+    MethodSubject testMethod = mainClass.uniqueMethodWithOriginalName("fieldTest");
     Assert.assertTrue(testMethod.isPresent());
     Iterator<FieldAccessInstructionSubject> iterator =
         testMethod.iterateInstructions(InstructionSubject::isFieldAccess);
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
index 2e726b0..1870c7e 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
@@ -69,9 +69,9 @@
             inspector -> {
               assertThat(inspector.clazz(A.class), isPresent());
               assertThat(inspector.clazz(A.class).init(), isAbsent());
-              assertThat(inspector.clazz(A.class).uniqueFieldWithName("y"), isPresent());
+              assertThat(inspector.clazz(A.class).uniqueFieldWithOriginalName("y"), isPresent());
               assertThat(
-                  inspector.clazz(A.class).uniqueFieldWithName("x"),
+                  inspector.clazz(A.class).uniqueFieldWithOriginalName("x"),
                   fullMode ? isAbsent() : isPresent());
             })
         .assertFailureWithErrorThatThrows(NoSuchMethodException.class);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
index 7c3a2d9..5559309 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
@@ -88,9 +88,10 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(ClassForIf.class);
               assertThat(classSubject, isPresent());
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              MethodSubject methodSubject =
+                  classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, not(isPresent()));
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, isPresent());
               assertFalse(methodSubject.getMethod().accessFlags.isPublic());
               classSubject = inspector.clazz(ClassForSubsequent.class);
@@ -122,17 +123,18 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(ClassForIf.class);
               assertThat(classSubject, isPresent());
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              MethodSubject methodSubject =
+                  classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, not(isPresent()));
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, isPresent());
               assertTrue(methodSubject.getMethod().accessFlags.isPublic());
 
               classSubject = inspector.clazz(ClassForSubsequent.class);
               assertThat(classSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, not(isPresent()));
             });
   }
@@ -161,17 +163,18 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(ClassForIf.class);
               assertThat(classSubject, isPresent());
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              MethodSubject methodSubject =
+                  classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, not(isPresent()));
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, isPresent());
               assertTrue(methodSubject.getMethod().accessFlags.isPublic());
 
               classSubject = inspector.clazz(ClassForSubsequent.class);
               assertThat(classSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, not(isPresent()));
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, isPresent());
               assertEquals(shrinker.isR8(), methodSubject.getMethod().accessFlags.isPublic());
             });
@@ -201,16 +204,17 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(ClassForIf.class);
               assertThat(classSubject, isPresent());
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              MethodSubject methodSubject =
+                  classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, not(isPresent()));
 
               classSubject = inspector.clazz(ClassForSubsequent.class);
               assertThat(classSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, not(isPresent()));
             });
   }
@@ -239,16 +243,17 @@
             inspector -> {
               ClassSubject classSubject = inspector.clazz(ClassForIf.class);
               assertThat(classSubject, isPresent());
-              MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              MethodSubject methodSubject =
+                  classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, not(isPresent()));
 
               classSubject = inspector.clazz(ClassForSubsequent.class);
               assertThat(classSubject, isPresent());
-              methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
               assertThat(methodSubject, not(isPresent()));
-              methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+              methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
               assertThat(methodSubject, isPresent());
               assertEquals(shrinker.isR8(), methodSubject.getMethod().accessFlags.isPublic());
             });
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
index 70f8903..5f89295 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
@@ -148,13 +148,13 @@
             codeInspector -> {
               ClassSubject aSubject = codeInspector.clazz(A.class);
               assertThat(aSubject, isPresent());
-              assertThat(aSubject.uniqueMethodWithName("a"), isPresent());
+              assertThat(aSubject.uniqueMethodWithOriginalName("a"), isPresent());
               ClassSubject bSubject = codeInspector.clazz(B.class);
               assertThat(bSubject, isPresent());
-              assertThat(bSubject.uniqueMethodWithName("b"), isPresent());
+              assertThat(bSubject.uniqueMethodWithOriginalName("b"), isPresent());
               ClassSubject cSubject = codeInspector.clazz(C.class);
               assertThat(cSubject, isPresent());
-              assertThat(cSubject.uniqueMethodWithName("c"), isPresent());
+              assertThat(cSubject.uniqueMethodWithOriginalName("c"), isPresent());
             });
     assertEquals(expectedClassEvaluations, box.data.numberOfProguardIfRuleClassEvaluations);
     assertEquals(expectedMemberEvaluations, box.data.numberOfProguardIfRuleMemberEvaluations);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
index fdef324..28b399c 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
@@ -52,7 +52,7 @@
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertThat(bClassSubject.uniqueMethodWithName("m"), isAbsent());
+    assertThat(bClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
index 7a0d692..8149782 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
@@ -69,7 +69,9 @@
   private static void assertHasStaticGet(
       boolean expected, String methodName, CodeInspector inspector) {
     MethodSubject method =
-        inspector.clazz(StaticFinalFieldInliningSource.class).uniqueMethodWithName(methodName);
+        inspector
+            .clazz(StaticFinalFieldInliningSource.class)
+            .uniqueMethodWithOriginalName(methodName);
     assertEquals(
         method.getMethod().codeToString(),
         expected,
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
index 5a27372..1defdee 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
@@ -62,11 +62,12 @@
             .inspector();
 
     assertTrue(inspector.clazz(TestClass.class).isPublic());
-    assertThat(inspector.clazz(TestClass.class).uniqueFieldWithName("field"), isPublic());
+    assertThat(inspector.clazz(TestClass.class).uniqueFieldWithOriginalName("field"), isPublic());
     assertThat(
-        inspector.clazz(TestClass.class).uniqueMethodWithName("privateMethod"),
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("privateMethod"),
         allOf(isPublic(), isFinal()));
-    assertThat(inspector.clazz(TestClass.class).uniqueMethodWithName("virtualMethod"), isPublic());
+    assertThat(
+        inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("virtualMethod"), isPublic());
 
     assertThat(inspector.clazz(Unused1.class), isPresent());
     assertThat(inspector.clazz(Unused2.class), isPresent());
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
index e841ffc..c74b2b1 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
@@ -62,7 +62,9 @@
 
   private void inspect(CodeInspector inspector) {
     MethodSubject methodSubject =
-        inspector.clazz(IfRuleWithApplyMappingTestClass.class).uniqueMethodWithName("method");
+        inspector
+            .clazz(IfRuleWithApplyMappingTestClass.class)
+            .uniqueMethodWithOriginalName("method");
     assertThat(methodSubject, isPresent());
     assertEquals(
         A.class.getTypeName(),
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
index 01d977a..0b486ff 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
@@ -88,8 +88,8 @@
     if (parameters.isCfRuntime()) {
       ClassSubject itfClass = inspector.clazz(Interface.class.getTypeName());
       assertThat(itfClass, isPresent());
-      assertThat(itfClass.uniqueMethodWithName("staticMethod"), isPresent());
-      assertThat(itfClass.uniqueMethodWithName("virtualMethod"), isPresent());
+      assertThat(itfClass.uniqueMethodWithOriginalName("staticMethod"), isPresent());
+      assertThat(itfClass.uniqueMethodWithOriginalName("virtualMethod"), isPresent());
       assertThat(inspector.clazz(Unused1.class), isPresent());
       assertThat(inspector.clazz(Unused2.class), isPresent());
       return;
@@ -100,7 +100,7 @@
 
     // NeverInline is only applicable to the static method at this point (could change).
     assertEquals(1, classSubject.allMethods().size());
-    MethodSubject staticMethodSubject = classSubject.uniqueMethodWithName("staticMethod");
+    MethodSubject staticMethodSubject = classSubject.uniqueMethodWithOriginalName("staticMethod");
     assertThat(staticMethodSubject, allOf(isPresent(), isPublic(), isStatic()));
     assertTrue(staticMethodSubject.streamInstructions().anyMatch(i -> i.isConstString(STATIC_STR)));
 
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
index 8fab4c1..45698a5 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
@@ -51,7 +51,7 @@
               ClassSubject classBSubject = inspector.clazz(B.class);
               assertThat(classBSubject, isPresent());
               assertThat(classBSubject.init(), isPresent());
-              assertThat(classBSubject.uniqueMethodWithName("greet"), isPresent());
+              assertThat(classBSubject.uniqueMethodWithOriginalName("greet"), isPresent());
               assertEquals(2, classBSubject.allMethods().size());
             })
         .run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
index 9dd4b60..6f80b77 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
@@ -57,7 +57,7 @@
     ClassSubject classSubject = inspector.clazz(A.class);
     assertThat(classSubject, isPresent());
 
-    FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+    FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
     assertThat(fieldSubject, isPresentAndNotRenamed());
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
index e42dfe3..1a13a8d 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
@@ -97,7 +97,7 @@
   private void checkClassAndMethodIsPresent(CodeInspector inspector, Class<?> clazz) {
     ClassSubject clazzSubject = inspector.clazz(clazz);
     assertThat(clazzSubject, isPresent());
-    MethodSubject foo = clazzSubject.uniqueMethodWithName("foo");
+    MethodSubject foo = clazzSubject.uniqueMethodWithOriginalName("foo");
     assertThat(foo, isPresentAndNotRenamed());
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
index 4f8131d..41f3dcc 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
@@ -71,7 +71,7 @@
     assertThat(classSubject, isPresent());
 
     MethodSubject method;
-    method = classSubject.uniqueMethodWithName("apiNoArgs");
+    method = classSubject.uniqueMethodWithOriginalName("apiNoArgs");
     assertThat(method, isPresent());
     assertEquals(keepParameterNames, method.hasLocalVariableTable());
     if (keepParameterNames) {
@@ -83,12 +83,12 @@
       assertTrue(method.getLocalVariableTable().isEmpty());
     }
 
-    method = classSubject.uniqueMethodWithName("apiNoArgsStatic");
+    method = classSubject.uniqueMethodWithOriginalName("apiNoArgsStatic");
     assertThat(method, isPresent());
     assertFalse(method.hasLocalVariableTable());
     assertTrue(method.getLocalVariableTable().isEmpty());
 
-    method = classSubject.uniqueMethodWithName("api1");
+    method = classSubject.uniqueMethodWithOriginalName("api1");
     assertThat(method, isPresent());
     assertEquals(keepParameterNames, method.hasLocalVariableTable());
     if (keepParameterNames) {
@@ -112,7 +112,7 @@
       assertTrue(method.getLocalVariableTable().isEmpty());
     }
 
-    method = classSubject.uniqueMethodWithName("api2");
+    method = classSubject.uniqueMethodWithOriginalName("api2");
     assertThat(method, isPresent());
     assertEquals(keepParameterNames, method.hasLocalVariableTable());
     if (keepParameterNames) {
@@ -132,7 +132,7 @@
       assertTrue(method.getLocalVariableTable().isEmpty());
     }
 
-    method = classSubject.uniqueMethodWithName("api3");
+    method = classSubject.uniqueMethodWithOriginalName("api3");
     assertThat(method, isPresent());
     assertEquals(keepParameterNames, method.hasLocalVariableTable());
     if (keepParameterNames) {
@@ -193,7 +193,7 @@
 
     MethodSubject method;
     for (String name : new String[] {"apiNoArgs", "apiNoArgsStatic", "api1", "api2", "api3"}) {
-      method = classSubject.uniqueMethodWithName(name);
+      method = classSubject.uniqueMethodWithOriginalName(name);
       assertThat(method, isPresent());
       assertEquals(enableMinification, method.isRenamed());
       assertFalse(method.hasLocalVariableTable());
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
index abd2407..0b91059 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
@@ -62,7 +62,7 @@
     ClassSubject classSubject = inspector.clazz("Api");
     assertThat(classSubject, isPresent());
 
-    MethodSubject method = classSubject.uniqueMethodWithName("api1");
+    MethodSubject method = classSubject.uniqueMethodWithOriginalName("api1");
     assertThat(method, isPresent());
 
     assertEquals(keepParameterNames, method.hasLocalVariableTable());
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
index 94bdbf1..915d92b 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
@@ -6,6 +6,7 @@
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
 
+import com.android.tools.r8.JdkClassFileProvider;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -45,6 +46,7 @@
   public void test() throws Throwable {
     testForR8(Backend.CF)
         .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+        .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
         .addKeepRuleFiles(MAIN_KEEP)
         .addKeepRules(WHY_ARE_YOU_KEEPING_ALL)
         .collectStdout()
diff --git a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
index 104f2cd..2699e27 100644
--- a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
@@ -68,7 +68,7 @@
     for (Class<?> nonEscapingClass : nonEscapingClasses) {
       ClassSubject classSubject = inspector.clazz(nonEscapingClass);
       assertThat(classSubject, isPresent());
-      assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
+      assertThat(classSubject.uniqueMethodWithOriginalName("toString"), not(isPresent()));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
index 9fe2a68..438355c 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
@@ -74,23 +74,26 @@
   private void checkMethods(CodeInspector inspector, Set<String> expected, Shrinker shrinker) {
     ClassSubject superSubject = inspector.clazz(Super.class);
     assertThat(superSubject, isPresent());
-    MethodSubject m1 = superSubject.uniqueMethodWithName("m1");
+    MethodSubject m1 = superSubject.uniqueMethodWithOriginalName("m1");
     assertEquals(expected.contains("m1") && shrinker != Shrinker.R8Full, m1.isPresent());
     if (m1.isPresent()) {
       assertTrue(m1.isAbstract());
     }
     ClassSubject subSubject = inspector.clazz(Sub.class);
     assertThat(subSubject, isPresent());
-    MethodSubject m2 = subSubject.uniqueMethodWithName("m2");
+    MethodSubject m2 = subSubject.uniqueMethodWithOriginalName("m2");
     assertEquals(expected.contains("m2") && shrinker != Shrinker.R8Full, m2.isPresent());
     if (m2.isPresent()) {
       assertTrue(m2.isAbstract());
     }
     ClassSubject subSubSubject = inspector.clazz(SubSub.class);
     assertThat(subSubSubject, isPresent());
-    assertEquals(expected.contains("m1"), subSubSubject.uniqueMethodWithName("m1").isPresent());
-    assertEquals(expected.contains("m2"), subSubSubject.uniqueMethodWithName("m2").isPresent());
-    assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+    assertEquals(
+        expected.contains("m1"), subSubSubject.uniqueMethodWithOriginalName("m1").isPresent());
+    assertEquals(
+        expected.contains("m2"), subSubSubject.uniqueMethodWithOriginalName("m2").isPresent());
+    assertEquals(
+        expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
   }
 
   private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
index 2961a50..2cd5ff7 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
@@ -54,7 +54,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(J.class);
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
               assertThat(inspector.clazz(I.class), not(isPresent()));
             });
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
index aa1fe71..cbb3fc9 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
@@ -56,7 +56,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(J.class);
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+              assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
               assertThat(inspector.clazz(I.class), not(isPresent()));
             });
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
index 91f4153..4331c76 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
@@ -53,7 +53,8 @@
                 codeInspector -> {
                   assertThat(codeInspector.clazz(A.class), isPresent());
                   assertThat(
-                      codeInspector.clazz(A.class).uniqueMethodWithName("foo"), not(isPresent()));
+                      codeInspector.clazz(A.class).uniqueMethodWithOriginalName("foo"),
+                      not(isPresent()));
                 });
     testForRuntime(parameters)
         .addProgramClasses(Main.class)
@@ -77,7 +78,8 @@
                   assertThat(codeInspector.clazz(A.class), not(isPresent()));
                   assertThat(codeInspector.clazz(B.class), isPresent());
                   assertThat(
-                      codeInspector.clazz(B.class).uniqueMethodWithName("foo"), not(isPresent()));
+                      codeInspector.clazz(B.class).uniqueMethodWithOriginalName("foo"),
+                      not(isPresent()));
                 });
     testForRuntime(parameters)
         .addProgramClasses(Main.class)
@@ -100,12 +102,14 @@
             .inspect(
                 codeInspector -> {
                   assertThat(codeInspector.clazz(A.class), isPresent());
-                  assertThat(codeInspector.clazz(A.class).uniqueMethodWithName("foo"), isPresent());
+                  assertThat(
+                      codeInspector.clazz(A.class).uniqueMethodWithOriginalName("foo"),
+                      isPresent());
                   assertThat(codeInspector.clazz(B.class), isPresent());
                   // TODO(b/144409021): We should be able to remove this.
                   assertEquals(
                       parameters.isDexRuntime(),
-                      codeInspector.clazz(B.class).uniqueMethodWithName("foo").isPresent());
+                      codeInspector.clazz(B.class).uniqueMethodWithOriginalName("foo").isPresent());
                 });
     testForRuntime(parameters)
         .addProgramClasses(Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
index c8b8be2..ae43926 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
@@ -52,7 +52,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(A.class);
               assertThat(clazz, isPresent());
-              assertThat(clazz.uniqueMethodWithName("foo"), isPresent());
+              assertThat(clazz.uniqueMethodWithOriginalName("foo"), isPresent());
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
index 54e57dd..cc63bd8 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
@@ -105,13 +105,16 @@
   private void checkMethods(CodeInspector inspector, Set<String> expected) {
     ClassSubject superSubject = inspector.clazz(Super.class);
     assertThat(superSubject, isPresent());
-    assertEquals(expected.contains("m1"), superSubject.uniqueMethodWithName("m1").isPresent());
+    assertEquals(
+        expected.contains("m1"), superSubject.uniqueMethodWithOriginalName("m1").isPresent());
     ClassSubject subSubject = inspector.clazz(Sub.class);
     assertThat(subSubject, isPresent());
-    assertEquals(expected.contains("m2"), subSubject.uniqueMethodWithName("m2").isPresent());
+    assertEquals(
+        expected.contains("m2"), subSubject.uniqueMethodWithOriginalName("m2").isPresent());
     ClassSubject subSubSubject = inspector.clazz(SubSub.class);
     assertThat(subSubSubject, isPresent());
-    assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+    assertEquals(
+        expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
   }
 
   private void checkAllMethodsAndAllConstructors(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
index e2f3886..ee03c78 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
@@ -62,13 +62,16 @@
   private void checkMethods(CodeInspector inspector, Set<String> expected) {
     ClassSubject superSubject = inspector.clazz(Super.class);
     assertThat(superSubject, isPresent());
-    assertEquals(expected.contains("m1"), superSubject.uniqueMethodWithName("m1").isPresent());
+    assertEquals(
+        expected.contains("m1"), superSubject.uniqueMethodWithOriginalName("m1").isPresent());
     ClassSubject subSubject = inspector.clazz(Sub.class);
     assertThat(subSubject, isPresent());
-    assertEquals(expected.contains("m2"), subSubject.uniqueMethodWithName("m2").isPresent());
+    assertEquals(
+        expected.contains("m2"), subSubject.uniqueMethodWithOriginalName("m2").isPresent());
     ClassSubject subSubSubject = inspector.clazz(SubSub.class);
     assertThat(subSubSubject, isPresent());
-    assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+    assertEquals(
+        expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
   }
 
   private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
index bb5b668..9bd8465 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
@@ -66,15 +66,16 @@
     assertThat(superSubject, isPresent());
     assertEquals(
         shrinker != Shrinker.R8Full && expected.contains("m1"),
-        superSubject.uniqueMethodWithName("m1").isPresent());
+        superSubject.uniqueMethodWithOriginalName("m1").isPresent());
     ClassSubject subSubject = inspector.clazz(Sub.class);
     assertThat(subSubject, isPresent());
     assertEquals(
         shrinker != Shrinker.R8Full && expected.contains("m2"),
-        subSubject.uniqueMethodWithName("m2").isPresent());
+        subSubject.uniqueMethodWithOriginalName("m2").isPresent());
     ClassSubject subSubSubject = inspector.clazz(SubSub.class);
     assertThat(subSubSubject, isPresent());
-    assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+    assertEquals(
+        expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
   }
 
   public String allMethodsOutput(Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
index 5f8bc2e..94f4646 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
@@ -71,13 +71,15 @@
   private void checkAllMethods(CodeInspector inspector, Shrinker shrinker, String name) {
     ClassSubject superSubject = inspector.clazz(Super.class);
     assertThat(superSubject, isPresent());
-    assertEquals(shrinker != Shrinker.R8Full, superSubject.uniqueMethodWithName(name).isPresent());
+    assertEquals(
+        shrinker != Shrinker.R8Full, superSubject.uniqueMethodWithOriginalName(name).isPresent());
     ClassSubject subSubject = inspector.clazz(Sub.class);
     assertThat(subSubject, isPresent());
-    assertEquals(shrinker != Shrinker.R8Full, subSubject.uniqueMethodWithName(name).isPresent());
+    assertEquals(
+        shrinker != Shrinker.R8Full, subSubject.uniqueMethodWithOriginalName(name).isPresent());
     ClassSubject subSubSubject = inspector.clazz(SubSub.class);
     assertThat(subSubSubject, isPresent());
-    assertThat(subSubSubject.uniqueMethodWithName(name), isPresent());
+    assertThat(subSubSubject.uniqueMethodWithOriginalName(name), isPresent());
   }
 
   private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java b/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
index 82b7339..83fd6bb 100644
--- a/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
@@ -59,52 +59,52 @@
 
     assertEquals(
         includePublic && includeNonStatic,
-        classSubject.uniqueMethodWithName("publicMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("publicMethod").isPresent());
     assertEquals(
         includeProtected && includeNonStatic,
-        classSubject.uniqueMethodWithName("protectedMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("protectedMethod").isPresent());
     assertEquals(
         includePrivate && includeNonStatic,
-        classSubject.uniqueMethodWithName("privateMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("privateMethod").isPresent());
     assertEquals(
         includePackagePrivate && includeNonStatic,
-        classSubject.uniqueMethodWithName("packagePrivateMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("packagePrivateMethod").isPresent());
     assertEquals(
         includePublic && includeStatic,
-        classSubject.uniqueMethodWithName("publicStaticMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("publicStaticMethod").isPresent());
     assertEquals(
         includeProtected && includeStatic,
-        classSubject.uniqueMethodWithName("protectedStaticMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("protectedStaticMethod").isPresent());
     assertEquals(
         includePrivate && includeStatic,
-        classSubject.uniqueMethodWithName("privateStaticMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("privateStaticMethod").isPresent());
     assertEquals(
         includePackagePrivate && includeStatic,
-        classSubject.uniqueMethodWithName("packagePrivateStaticMethod").isPresent());
+        classSubject.uniqueMethodWithOriginalName("packagePrivateStaticMethod").isPresent());
     assertEquals(
         includePublic && includeNonStatic,
-        classSubject.uniqueFieldWithName("publicField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("publicField").isPresent());
     assertEquals(
         includeProtected && includeNonStatic,
-        classSubject.uniqueFieldWithName("protectedField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("protectedField").isPresent());
     assertEquals(
         includePrivate && includeNonStatic,
-        classSubject.uniqueFieldWithName("privateField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("privateField").isPresent());
     assertEquals(
         includePackagePrivate && includeNonStatic,
-        classSubject.uniqueFieldWithName("packagePrivateField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("packagePrivateField").isPresent());
     assertEquals(
         includePublic && includeStatic,
-        classSubject.uniqueFieldWithName("publicStaticField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("publicStaticField").isPresent());
     assertEquals(
         includeProtected && includeStatic,
-        classSubject.uniqueFieldWithName("protectedStaticField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("protectedStaticField").isPresent());
     assertEquals(
         includePrivate && includeStatic,
-        classSubject.uniqueFieldWithName("privateStaticField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("privateStaticField").isPresent());
     assertEquals(
         includePackagePrivate && includeStatic,
-        classSubject.uniqueFieldWithName("packagePrivateStaticField").isPresent());
+        classSubject.uniqueFieldWithOriginalName("packagePrivateStaticField").isPresent());
   }
 
   public void runTest(
diff --git a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
index 8a4113a..3743fb8 100644
--- a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
@@ -58,7 +58,7 @@
             .inspector();
     ClassSubject itf = inspector.clazz(M_I);
     assertThat(itf, isPresent());
-    MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
+    MethodSubject mtd = itf.uniqueMethodWithOriginalName("onEnterForeground");
     assertThat(mtd, isAbsent());
   }
 
@@ -77,7 +77,7 @@
             .inspector();
     ClassSubject itf = inspector.clazz(M_I);
     assertThat(itf, isPresent());
-    MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
+    MethodSubject mtd = itf.uniqueMethodWithOriginalName("onEnterForeground");
     assertThat(mtd, isPresentAndNotRenamed());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java b/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
index 9d2b858..3e3a646 100644
--- a/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
@@ -64,7 +64,7 @@
               Assert.assertTrue(
                   inspector
                       .clazz(testClass)
-                      .uniqueMethodWithName("main")
+                      .uniqueMethodWithOriginalName("main")
                       .streamInstructions()
                       .anyMatch(this::isInvokeGetField));
             })
diff --git a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
index ad6b6ea..58c7558 100644
--- a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
@@ -118,7 +118,7 @@
     } else {
       assertThat(method, not(isPresent()));
       assertThat(companionClass, isPresent());
-      assertThat(companionClass.uniqueMethodWithName("method"), isPresent());
+      assertThat(companionClass.uniqueMethodWithOriginalName("method"), isPresent());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/smali/JumboStringTest.java b/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
index e7b5fe6..d3a9e4d 100644
--- a/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
+++ b/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
@@ -92,7 +92,7 @@
             inspector -> {
               ClassSubject main = inspector.clazz(DEFAULT_CLASS_NAME);
               assertThat(main, isPresent());
-              MethodSubject method = main.uniqueMethodWithName(DEFAULT_METHOD_NAME);
+              MethodSubject method = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME);
               assertThat(method, isPresent());
               assertTrue(method.streamInstructions().anyMatch(InstructionSubject::isJumboString));
             });
@@ -143,10 +143,10 @@
             inspector -> {
               ClassSubject main = inspector.clazz(DEFAULT_CLASS_NAME);
               assertThat(main, isPresent());
-              MethodSubject method = main.uniqueMethodWithName(DEFAULT_METHOD_NAME);
+              MethodSubject method = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME);
               assertThat(method, isPresent());
               assertTrue(method.streamInstructions().anyMatch(InstructionSubject::isJumboString));
-              MethodSubject method2 = main.uniqueMethodWithName(DEFAULT_METHOD_NAME + "2");
+              MethodSubject method2 = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME + "2");
               assertThat(method2, isPresent());
               assertTrue(method2.streamInstructions().anyMatch(InstructionSubject::isJumboString));
             });
diff --git a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
index 23e8577..77909c0 100644
--- a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
+++ b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
@@ -59,13 +59,15 @@
               ClassSubject mainClassSubject = inspector.clazz(Main.class);
               assertThat(mainClassSubject, isPresent());
               // The postStartupMethod() should be inlined into PostStartupClass.runPostStartup().
-              assertThat(mainClassSubject.uniqueMethodWithName("postStartupMethod"), isAbsent());
+              assertThat(
+                  mainClassSubject.uniqueMethodWithOriginalName("postStartupMethod"), isAbsent());
 
               ClassSubject postStartupClassSubject = inspector.clazz(PostStartupClass.class);
               assertThat(postStartupClassSubject, isPresent());
               // The runPostStartup() method must not be inlined into Main.main().
               assertThat(
-                  postStartupClassSubject.uniqueMethodWithName("runPostStartup"), isPresent());
+                  postStartupClassSubject.uniqueMethodWithOriginalName("runPostStartup"),
+                  isPresent());
             })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello, world!");
diff --git a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
index db55acb..f8a5438 100644
--- a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
+++ b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
@@ -84,7 +84,8 @@
               assertTrue(
                   mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isThrow));
 
-              MethodSubject onClickMethodSubject = mainClassSubject.uniqueMethodWithName("onClick");
+              MethodSubject onClickMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("onClick");
               assertThat(onClickMethodSubject, isPresent());
               assertTrue(
                   onClickMethodSubject.streamInstructions().anyMatch(InstructionSubject::isThrow));
@@ -93,7 +94,8 @@
               ClassSubject startupClassSubject = primaryDexInspector.clazz(AStartupClass.class);
               assertThat(startupClassSubject, isPresent());
 
-              MethodSubject startupMethodSubject = startupClassSubject.uniqueMethodWithName("foo");
+              MethodSubject startupMethodSubject =
+                  startupClassSubject.uniqueMethodWithOriginalName("foo");
               assertThat(startupMethodSubject, isPresent());
               assertTrue(
                   startupMethodSubject.streamInstructions().noneMatch(InstructionSubject::isThrow));
@@ -113,7 +115,7 @@
                       .anyMatch(InstructionSubject::isThrow));
 
               MethodSubject nonStartupMethodSubject =
-                  nonStartupClassSubject.uniqueMethodWithName("bar");
+                  nonStartupClassSubject.uniqueMethodWithOriginalName("bar");
               assertThat(nonStartupMethodSubject, isPresent());
               assertTrue(
                   nonStartupMethodSubject
diff --git a/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
index c5bfa0d..35d810b 100644
--- a/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
@@ -50,7 +50,7 @@
               ClassSubject iClassSubject = inspector.clazz(I.class);
               assertThat(iClassSubject, isPresent());
 
-              MethodSubject iMethodSubject = iClassSubject.uniqueMethodWithName("m");
+              MethodSubject iMethodSubject = iClassSubject.uniqueMethodWithOriginalName("m");
               assertThat(iClassSubject, isPresent());
 
               MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/utils/Smali.java b/src/test/java/com/android/tools/r8/utils/Smali.java
index 30274f0..4321812 100644
--- a/src/test/java/com/android/tools/r8/utils/Smali.java
+++ b/src/test/java/com/android/tools/r8/utils/Smali.java
@@ -112,7 +112,7 @@
     try {
       DexApplication dexApp = new ApplicationReader(app, options, Timing.empty()).read(executor);
       ApplicationWriter writer =
-          new ApplicationWriter(
+          ApplicationWriter.create(
               AppView.createForD8(
                   AppInfo.createInitialAppInfo(
                       dexApp, GlobalSyntheticsStrategy.forNonSynthesizing())),
diff --git a/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java b/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
index 8279af3..acadcc6 100644
--- a/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
+++ b/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
@@ -6,13 +6,29 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.StringUtils.BraceType;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
-public class StringUtilsTest {
+@RunWith(Parameterized.class)
+public class StringUtilsTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public StringUtilsTest(TestParameters parameters) {
+    parameters.assertNoneRuntime();
+  }
 
   @Test
   public void splitLines() {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
index a790753..e353ee6 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
@@ -46,7 +46,7 @@
   }
 
   @Override
-  public MethodSubject uniqueMethodWithName(String name) {
+  public MethodSubject uniqueMethodWithOriginalName(String name) {
     return new AbsentMethodSubject();
   }
 
@@ -70,7 +70,7 @@
   }
 
   @Override
-  public FieldSubject uniqueFieldWithName(String name) {
+  public FieldSubject uniqueFieldWithOriginalName(String name) {
     return new AbsentFieldSubject();
   }
 
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index db4985c..0b2b52c 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -105,7 +105,7 @@
 
   public abstract MethodSubject uniqueMethodThatMatches(Predicate<FoundMethodSubject> predicate);
 
-  public abstract MethodSubject uniqueMethodWithName(String name);
+  public abstract MethodSubject uniqueMethodWithOriginalName(String name);
 
   public abstract MethodSubject uniqueMethodWithFinalName(String name);
 
@@ -172,7 +172,7 @@
 
   public abstract FieldSubject field(String type, String name);
 
-  public abstract FieldSubject uniqueFieldWithName(String name);
+  public abstract FieldSubject uniqueFieldWithOriginalName(String name);
 
   public abstract FieldSubject uniqueFieldWithFinalName(String name);
 
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 2c304ad..ff35c6e 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
@@ -148,7 +148,7 @@
   }
 
   @Override
-  public MethodSubject uniqueMethodWithName(String name) {
+  public MethodSubject uniqueMethodWithOriginalName(String name) {
     MethodSubject methodSubject = null;
     for (FoundMethodSubject candidate : allMethods()) {
       if (candidate.getOriginalName(false).equals(name)) {
@@ -219,13 +219,14 @@
   }
 
   @Override
-  public FieldSubject uniqueFieldWithName(String name) {
-    return uniqueFieldWithName(name, null);
+  public FieldSubject uniqueFieldWithOriginalName(String name) {
+    return uniqueFieldWithOriginalName(name, null);
   }
 
   // TODO(b/169882658): This should be removed when we have identity mappings for ambiguous cases.
-  public FieldSubject uniqueFieldWithName(String name, TypeReference originalType) {
+  public FieldSubject uniqueFieldWithOriginalName(String name, TypeReference originalType) {
     Retracer retracer = codeInspector.retrace();
+    ClassReference finalReference = getFinalReference();
     Set<FoundFieldSubject> candidates = Sets.newIdentityHashSet();
     Set<FoundFieldSubject> sameTypeCandidates = Sets.newIdentityHashSet();
     for (FoundFieldSubject candidate : allFields()) {
@@ -238,7 +239,8 @@
         }
       }
       retracer
-          .retraceField(fieldReference)
+          .retraceClass(finalReference)
+          .lookupField(candidate.getFinalName())
           .forEach(
               element -> {
                 RetracedFieldReference field = element.getField();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java b/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
index 4d4c84b..c06e09d 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
@@ -225,7 +225,7 @@
           continue;
         }
         FieldSubject fieldSubject =
-            classSubject.uniqueFieldWithName(extensionField.name.toSourceString());
+            classSubject.uniqueFieldWithOriginalName(extensionField.name.toSourceString());
         if (fieldSubject.isPresent()) {
           generatedExtensionRegistryStats.spuriouslyRetainedExtensionFields.add(extensionField);
         }
diff --git a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
index f44fff9..00a3fba 100644
--- a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
+++ b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
@@ -72,7 +72,8 @@
   }
 
   private void inspect(CodeInspector inspector) {
-    MethodSubject methodOfInterest = inspector.clazz(Greeter.class).uniqueMethodWithName("dead");
+    MethodSubject methodOfInterest =
+        inspector.clazz(Greeter.class).uniqueMethodWithOriginalName("dead");
     assertThat(methodOfInterest, isPresent());
     if (parameters.isCfRuntime() || parameters.getApiLevel().isLessThan(AndroidApiLevel.L)) {
       assertThat(methodOfInterest, not(isAbstract()));
diff --git a/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java b/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
index 3cc8749..03d7c66 100644
--- a/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
+++ b/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
@@ -68,7 +68,7 @@
                 assertThat(cameraDeviceUserClassSubject, isPresent());
 
                 MethodSubject mMethodSubject =
-                    cameraDeviceUserClassSubject.uniqueMethodWithName("m");
+                    cameraDeviceUserClassSubject.uniqueMethodWithOriginalName("m");
                 assertThat(mMethodSubject, isPresent());
                 assertThat(mMethodSubject, invokesMethodWithName("close"));
               }
diff --git a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
index 524abea..6bb56ca 100644
--- a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
@@ -1 +1 @@
-ae103f657ce219b839706397baac799745d46049
\ No newline at end of file
+ed1a6a57d899d32cc749160872cad5c2130566b7
\ No newline at end of file
diff --git a/third_party/retrace/binary_compatibility.tar.gz.sha1 b/third_party/retrace/binary_compatibility.tar.gz.sha1
index 750079a..5d61558 100644
--- a/third_party/retrace/binary_compatibility.tar.gz.sha1
+++ b/third_party/retrace/binary_compatibility.tar.gz.sha1
@@ -1 +1 @@
-ed632240a9f5652ed988ccf84c5f592a487d24c3
\ No newline at end of file
+189692be996b34e4ba4a069c148b20d7ff99abe7
\ No newline at end of file
diff --git a/tools/create_r8lib.py b/tools/create_r8lib.py
index c48eaca..b6189e6 100755
--- a/tools/create_r8lib.py
+++ b/tools/create_r8lib.py
@@ -96,7 +96,7 @@
   cmd.extend(['--source-file-template', source_file_template])
   cmd.extend(['--output', args.output])
   cmd.extend(['--pg-map-output', args.output + '.map'])
-  cmd.extend(['--lib', 'third_party/openjdk/openjdk-rt-1.8/rt.jar'])
+  cmd.extend(['--lib', jdk.GetJdkHome()])
   if args.pg_conf:
     for pgconf in args.pg_conf:
       cmd.extend(['--pg-conf', pgconf])