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/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/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/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/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/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/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/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..8002337 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
@@ -65,11 +65,11 @@
         classSubject.asFoundClassSubject().uniqueFieldWithName("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/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/RepackageProtectedInSamePackageTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
index c7f8a81..a208857 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
@@ -51,8 +51,8 @@
     ClassSubject clazz = inspector.clazz(Sub.class);
     assertThat(clazz, isPresent());
     assertThat(Sub.class, isNotRepackaged(inspector));
-    assertThat(clazz.uniqueFieldWithName("hashCodeCache"), isPresentAndRenamed());
-    assertThat(clazz.uniqueMethodWithName("calculateHashCode"), isPresentAndRenamed());
+    assertThat(clazz.uniqueFieldWithOriginalName("hashCodeCache"), isPresentAndRenamed());
+    assertThat(clazz.uniqueMethodWithOriginalName("calculateHashCode"), isPresentAndRenamed());
   }
 
   public static class Base {}
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/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/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/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/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..684cbfb 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,7 +219,7 @@
   }
 
   @Override
-  public FieldSubject uniqueFieldWithName(String name) {
+  public FieldSubject uniqueFieldWithOriginalName(String name) {
     return uniqueFieldWithName(name, null);
   }
 
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"));
               }