Merge commit 'eeb28eaf9e19fc60331601bb3c80c613e36b6c35' into dev-release
diff --git a/build.gradle b/build.gradle
index db4592a..812b438 100644
--- a/build.gradle
+++ b/build.gradle
@@ -646,6 +646,12 @@
}
setJdkCompilationWithCompatibility(
+ sourceSets.main.compileJavaTaskName,
+ 'jdk-11',
+ JavaVersion.VERSION_11,
+ false);
+
+setJdkCompilationWithCompatibility(
sourceSets.examplesJava9.compileJavaTaskName,
'openjdk-9.0.4',
JavaVersion.VERSION_1_9,
@@ -1037,7 +1043,7 @@
input,
"--output", output,
"--pg-map-output", output + ".map",
- "--lib", "third_party/openjdk/openjdk-rt-1.8/rt.jar"
+ "--lib", org.gradle.internal.jvm.Jvm.current().javaHome,
] + args + libs.collectMany { ["--lib", it] } + pgConfs.collectMany { ["--pg-conf", it] }
return baseR8CommandLine(allArgs)
}
diff --git a/src/library_desugar/jdk11/desugar_jdk_libs.json b/src/library_desugar/jdk11/desugar_jdk_libs.json
index 5adf5d1..9332de7 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs.json
@@ -6,6 +6,22 @@
"support_all_callbacks_from_library": true,
"common_flags": [
{
+ "api_level_below_or_equal": 32,
+ "rewrite_prefix": {
+ "java.util.concurrent.DesugarTimeUnit": "j$.util.concurrent.DesugarTimeUnit"
+ },
+ "retarget_method": {
+ "java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)": "java.util.concurrent.DesugarTimeUnit",
+ "java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()": "java.util.concurrent.DesugarTimeUnit",
+ "long java.util.concurrent.TimeUnit#convert(java.time.Duration)": "java.util.concurrent.DesugarTimeUnit"
+ },
+ "amend_library_method": [
+ "public static java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)",
+ "public java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()",
+ "public long java.util.concurrent.TimeUnit#convert(java.time.Duration)"
+ ]
+ },
+ {
"api_level_below_or_equal": 30,
"rewrite_prefix": {
"java.time.": "j$.time.",
@@ -20,8 +36,7 @@
"java.time.ZonedDateTime java.util.GregorianCalendar#toZonedDateTime()": "java.util.DesugarGregorianCalendar"
},
"wrapper_conversion": [
- "java.time.Clock",
- "java.time.temporal.ChronoUnit"
+ "java.time.Clock"
],
"custom_conversion": {
"java.time.Duration": "java.time.TimeConversions",
diff --git a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
index 8d31143..5a1d513 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
@@ -10,12 +10,21 @@
"rewrite_prefix": {
"java.net.URLDecoder": "j$.net.URLDecoder",
"java.net.URLEncoder": "j$.net.URLEncoder",
- "java.io.DesugarInputStream": "j$.io.DesugarInputStream"
+ "java.io.DesugarInputStream": "j$.io.DesugarInputStream",
+ "java.util.concurrent.DesugarTimeUnit": "j$.util.concurrent.DesugarTimeUnit"
+ },
+ "retarget_method": {
+ "java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)": "java.util.concurrent.DesugarTimeUnit",
+ "java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()": "java.util.concurrent.DesugarTimeUnit",
+ "long java.util.concurrent.TimeUnit#convert(java.time.Duration)": "java.util.concurrent.DesugarTimeUnit"
},
"retarget_method_with_emulated_dispatch": {
"long java.io.InputStream#transferTo(java.io.OutputStream)": "java.io.DesugarInputStream"
},
"amend_library_method": [
+ "public static java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)",
+ "public java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()",
+ "public long java.util.concurrent.TimeUnit#convert(java.time.Duration)",
"public long java.io.InputStream#transferTo(java.io.OutputStream)"
]
},
@@ -34,8 +43,7 @@
"java.time.ZonedDateTime java.util.GregorianCalendar#toZonedDateTime()": "java.util.DesugarGregorianCalendar"
},
"wrapper_conversion": [
- "java.time.Clock",
- "java.time.temporal.ChronoUnit"
+ "java.time.Clock"
],
"custom_conversion": {
"java.time.Duration": "java.time.TimeConversions",
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 068f2ec..f578416 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -333,7 +333,7 @@
if (options.isGeneratingClassFiles()) {
new CfApplicationWriter(appView, marker).write(options.getClassFileConsumer(), inputApp);
} else {
- new ApplicationWriter(appView, marker).write(executor, inputApp);
+ ApplicationWriter.create(appView, marker).write(executor, inputApp);
}
options.printWarnings();
} catch (ExecutionException e) {
@@ -428,7 +428,7 @@
ConvertedCfFiles convertedCfFiles = new ConvertedCfFiles();
new GenericSignatureRewriter(appView).run(appView.appInfo().classes(), executor);
new KotlinMetadataRewriter(appView).runForD8(executor);
- new ApplicationWriter(appView, marker, convertedCfFiles).write(executor);
+ ApplicationWriter.create(appView, marker, convertedCfFiles).write(executor);
AndroidApp.Builder builder = AndroidApp.builder(inputApp);
builder.getProgramResourceProviders().clear();
builder.addProgramResourceProvider(convertedCfFiles);
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 6ef6c416..71898e2 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -217,7 +217,7 @@
if (options.isGeneratingClassFiles()) {
new CfApplicationWriter(appView, marker).write(options.getClassFileConsumer(), inputApp);
} else {
- new ApplicationWriter(appView, marker).write(executorService, inputApp);
+ ApplicationWriter.create(appView, marker).write(executorService, inputApp);
}
} catch (IOException e) {
throw new RuntimeException("Cannot write application", e);
diff --git a/src/main/java/com/android/tools/r8/bisect/Bisect.java b/src/main/java/com/android/tools/r8/bisect/Bisect.java
index c7547a8..8a196d9 100644
--- a/src/main/java/com/android/tools/r8/bisect/Bisect.java
+++ b/src/main/java/com/android/tools/r8/bisect/Bisect.java
@@ -187,7 +187,7 @@
StringConsumer proguardMapConsumer = options.proguardMapConsumer;
AndroidAppConsumers compatSink = new AndroidAppConsumers(options);
ApplicationWriter writer =
- new ApplicationWriter(
+ ApplicationWriter.create(
AppView.createForD8(
AppInfo.createInitialAppInfo(app, GlobalSyntheticsStrategy.forNonSynthesizing())),
null);
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index 7db4fbd..10acb93 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -244,19 +244,27 @@
private AndroidApiLevel validateOrComputeMinApiLevel(
AndroidApiLevel computedMinApiLevel, DexReader dexReader) {
DexVersion version = dexReader.getDexVersion();
+ if (!options.testing.dexContainerExperiment
+ && version.getIntValue() == InternalOptions.EXPERIMENTAL_DEX_VERSION) {
+ throwIncompatibleDexVersionAndMinApi(version);
+ }
if (options.getMinApiLevel() == AndroidApiLevel.getDefault()) {
computedMinApiLevel = computedMinApiLevel.max(AndroidApiLevel.getMinAndroidApiLevel(version));
} else if (!version.matchesApiLevel(options.getMinApiLevel())) {
- throw new CompilationError(
- "Dex file with version '"
- + version.getIntValue()
- + "' cannot be used with min sdk level '"
- + options.getMinApiLevel()
- + "'.");
+ throwIncompatibleDexVersionAndMinApi(version);
}
return computedMinApiLevel;
}
+ private void throwIncompatibleDexVersionAndMinApi(DexVersion version) {
+ throw new CompilationError(
+ "Dex file with version '"
+ + version.getIntValue()
+ + "' cannot be used with min sdk level '"
+ + options.getMinApiLevel()
+ + "'.");
+ }
+
private void readProguardMap(
StringResource map,
DexApplication.Builder<?> builder,
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index 96b00bf..5f0d225 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -95,6 +95,7 @@
public final AppView<?> appView;
public final InternalOptions options;
+
private final CodeToKeep desugaredLibraryCodeToKeep;
private final Predicate<DexType> isTypeMissing;
private final Optional<Marker> currentMarker;
@@ -174,11 +175,7 @@
}
}
- public ApplicationWriter(AppView<?> appView, Marker marker) {
- this(appView, marker, null);
- }
-
- public ApplicationWriter(AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+ protected ApplicationWriter(AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
this.appView = appView;
this.options = appView.options();
this.desugaredLibraryCodeToKeep = CodeToKeep.createCodeToKeep(appView);
@@ -189,10 +186,27 @@
this.previousMarkers = appView.dexItemFactory().extractMarkers();
}
+ public static ApplicationWriter create(AppView<?> appView, Marker marker) {
+ return ApplicationWriter.create(appView, marker, null);
+ }
+
+ public static ApplicationWriter create(
+ AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+ if (appView.options().testing.dexContainerExperiment) {
+ return new ApplicationWriterExperimental(appView, marker, consumer);
+ } else {
+ return new ApplicationWriter(appView, marker, consumer);
+ }
+ }
+
private NamingLens getNamingLens() {
return appView.getNamingLens();
}
+ public CodeToKeep getDesugaredLibraryCodeToKeep() {
+ return desugaredLibraryCodeToKeep;
+ }
+
private List<VirtualFile> distribute(ExecutorService executorService)
throws ExecutionException, IOException {
Collection<DexProgramClass> classes = appView.appInfo().classes();
@@ -283,6 +297,52 @@
write(executorService, null);
}
+ protected Timing rewriteJumboStringsAndComputeDebugRepresentation(
+ VirtualFile virtualFile, List<LazyDexString> lazyDexStrings) {
+ Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+ computeOffsetMappingAndRewriteJumboStrings(virtualFile, lazyDexStrings, fileTiming);
+ DebugRepresentation.computeForFile(appView, virtualFile);
+ fileTiming.end();
+ return fileTiming;
+ }
+
+ protected Collection<Timing> rewriteJumboStringsAndComputeDebugRepresentation(
+ ExecutorService executorService,
+ List<VirtualFile> virtualFiles,
+ List<LazyDexString> lazyDexStrings)
+ throws ExecutionException {
+ return ThreadUtils.processItemsWithResults(
+ virtualFiles,
+ virtualFile ->
+ rewriteJumboStringsAndComputeDebugRepresentation(virtualFile, lazyDexStrings),
+ executorService);
+ }
+
+ protected void writeVirtualFiles(
+ ExecutorService executorService,
+ List<VirtualFile> virtualFiles,
+ List<DexString> forcedStrings,
+ Timing timing)
+ throws ExecutionException {
+ TimingMerger merger =
+ timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
+ Collection<Timing> timings =
+ ThreadUtils.processItemsWithResults(
+ virtualFiles,
+ virtualFile -> {
+ Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+ writeVirtualFile(virtualFile, fileTiming, forcedStrings);
+ fileTiming.end();
+ return fileTiming;
+ },
+ executorService);
+ merger.add(timings);
+ merger.end();
+ if (globalsSyntheticsConsumer != null) {
+ globalsSyntheticsConsumer.finished(appView);
+ }
+ }
+
public void write(ExecutorService executorService, AndroidApp inputApp)
throws IOException, ExecutionException {
Timing timing = appView.appInfo().app().timing;
@@ -337,17 +397,8 @@
TimingMerger merger =
timing.beginMerger("Pre-write phase", ThreadUtils.getNumberOfThreads(executorService));
Collection<Timing> timings =
- ThreadUtils.processItemsWithResults(
- virtualFiles,
- virtualFile -> {
- Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
- computeOffsetMappingAndRewriteJumboStrings(
- virtualFile, lazyDexStrings, fileTiming);
- DebugRepresentation.computeForFile(appView, virtualFile);
- fileTiming.end();
- return fileTiming;
- },
- executorService);
+ rewriteJumboStringsAndComputeDebugRepresentation(
+ executorService, virtualFiles, lazyDexStrings);
merger.add(timings);
merger.end();
}
@@ -370,26 +421,8 @@
}
timing.end();
- {
- // Write the actual dex code.
- TimingMerger merger =
- timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
- Collection<Timing> timings =
- ThreadUtils.processItemsWithResults(
- virtualFiles,
- virtualFile -> {
- Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
- writeVirtualFile(virtualFile, fileTiming, forcedStrings);
- fileTiming.end();
- return fileTiming;
- },
- executorService);
- merger.add(timings);
- merger.end();
- if (globalsSyntheticsConsumer != null) {
- globalsSyntheticsConsumer.finished(appView);
- }
- }
+ // Write the actual dex code.
+ writeVirtualFiles(executorService, virtualFiles, forcedStrings, timing);
// A consumer can manage the generated keep rules.
if (options.desugaredLibraryKeepRuleConsumer != null && !desugaredLibraryCodeToKeep.isNop()) {
@@ -881,7 +914,7 @@
* <p>If run multiple times on a class, the lowest index that is required to be a JumboString will
* be used.
*/
- private void rewriteCodeWithJumboStrings(
+ protected void rewriteCodeWithJumboStrings(
ObjectToOffsetMapping mapping,
Collection<DexProgramClass> classes,
DexApplication application) {
@@ -923,7 +956,7 @@
// Collect the non-fixed sections.
timing.time("collect", fileWriter::collect);
// Generate and write the bytes.
- return timing.time("generate", fileWriter::generate);
+ return timing.time("generate", () -> fileWriter.generate());
}
private static String mapMainDexListName(DexType type, NamingLens namingLens) {
@@ -956,7 +989,7 @@
}
}
- private void printItemUseInfo(VirtualFile virtualFile) {
+ protected void printItemUseInfo(VirtualFile virtualFile) {
if (options.testing.calculateItemUseCountInDex) {
synchronized (System.out) {
System.out.print("\"Item\"");
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java
new file mode 100644
index 0000000..021a904
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriterExperimental.java
@@ -0,0 +1,209 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.dex;
+
+import com.android.tools.r8.ByteBufferProvider;
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.DexFilePerClassFileConsumer;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.ProgramConsumer;
+import com.android.tools.r8.debuginfo.DebugRepresentation;
+import com.android.tools.r8.dex.FileWriter.ByteBufferResult;
+import com.android.tools.r8.dex.FileWriter.DexContainerSection;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.ObjectToOffsetMapping;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.Timing.TimingMerger;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+class ApplicationWriterExperimental extends ApplicationWriter {
+ protected ApplicationWriterExperimental(
+ AppView<?> appView, Marker marker, DexIndexedConsumer consumer) {
+ super(appView, marker, consumer);
+ }
+
+ @Override
+ protected Collection<Timing> rewriteJumboStringsAndComputeDebugRepresentation(
+ ExecutorService executorService,
+ List<VirtualFile> virtualFiles,
+ List<LazyDexString> lazyDexStrings)
+ throws ExecutionException {
+ // Collect strings from all virtual files into the last DEX section.
+ VirtualFile lastFile = virtualFiles.get(virtualFiles.size() - 1);
+ List<VirtualFile> allExceptLastFile = virtualFiles.subList(0, virtualFiles.size() - 1);
+ for (VirtualFile virtualFile : allExceptLastFile) {
+ lastFile.indexedItems.addStrings(virtualFile.indexedItems.getStrings());
+ }
+ Collection<Timing> timings = new ArrayList<>(virtualFiles.size());
+ // Compute string layout and handle jumbo strings for the last DEX section.
+ timings.add(rewriteJumboStringsAndComputeDebugRepresentation(lastFile, lazyDexStrings));
+ // Handle jumbo strings for the remaining DEX sections using the string ids in the last DEX
+ // section.
+ timings.addAll(
+ ThreadUtils.processItemsWithResults(
+ allExceptLastFile,
+ virtualFile ->
+ rewriteJumboStringsAndComputeDebugRepresentationWithExternalStringIds(
+ virtualFile, lazyDexStrings, lastFile.getObjectMapping()),
+ executorService));
+ return timings;
+ }
+
+ private Timing rewriteJumboStringsAndComputeDebugRepresentationWithExternalStringIds(
+ VirtualFile virtualFile, List<LazyDexString> lazyDexStrings, ObjectToOffsetMapping mapping) {
+ Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+ computeOffsetMappingAndRewriteJumboStringsWithExternalStringIds(
+ virtualFile, lazyDexStrings, fileTiming, mapping);
+ DebugRepresentation.computeForFile(appView, virtualFile);
+ fileTiming.end();
+ return fileTiming;
+ }
+
+ private void computeOffsetMappingAndRewriteJumboStringsWithExternalStringIds(
+ VirtualFile virtualFile,
+ List<LazyDexString> lazyDexStrings,
+ Timing timing,
+ ObjectToOffsetMapping mapping) {
+ if (virtualFile.isEmpty()) {
+ return;
+ }
+ timing.begin("Compute object offset mapping");
+ virtualFile.computeMapping(appView, lazyDexStrings.size(), timing, mapping);
+ timing.end();
+ timing.begin("Rewrite jumbo strings");
+ rewriteCodeWithJumboStrings(
+ virtualFile.getObjectMapping(), virtualFile.classes(), appView.appInfo().app());
+ timing.end();
+ }
+
+ @Override
+ protected void writeVirtualFiles(
+ ExecutorService executorService,
+ List<VirtualFile> virtualFiles,
+ List<DexString> forcedStrings,
+ Timing timing)
+ throws ExecutionException {
+ TimingMerger merger =
+ timing.beginMerger("Write files", ThreadUtils.getNumberOfThreads(executorService));
+ Collection<Timing> timings;
+ // TODO(b/249922554): Current limitations for the experimental flag.
+ assert globalsSyntheticsConsumer == null;
+ assert programConsumer == null;
+ virtualFiles.forEach(
+ virtualFile -> {
+ assert virtualFile.getPrimaryClassDescriptor() == null;
+ assert virtualFile.getFeatureSplit() == null;
+ });
+
+ ProgramConsumer consumer = options.getDexIndexedConsumer();
+ ByteBufferProvider byteBufferProvider = options.getDexIndexedConsumer();
+ DexOutputBuffer dexOutputBuffer = new DexOutputBuffer(byteBufferProvider);
+ byte[] tempForAssertions = new byte[] {};
+
+ int offset = 0;
+ timings = new ArrayList<>();
+ List<DexContainerSection> sections = new ArrayList<>();
+
+ // TODO(b/249922554): Write in parallel.
+ for (int i = 0; i < virtualFiles.size(); i++) {
+ VirtualFile virtualFile = virtualFiles.get(i);
+ Timing fileTiming = Timing.create("VirtualFile " + virtualFile.getId(), options);
+ assert forcedStrings.size() == 0;
+ DexContainerSection section =
+ writeVirtualFileSection(
+ virtualFile,
+ fileTiming,
+ forcedStrings,
+ offset,
+ dexOutputBuffer,
+ i == virtualFiles.size() - 1);
+
+ if (InternalOptions.assertionsEnabled()) {
+ // Check that writing did not modify already written sections.
+ byte[] outputSoFar = dexOutputBuffer.asArray();
+ for (int j = 0; j < offset; j++) {
+ assert tempForAssertions[j] == outputSoFar[j];
+ }
+ // Copy written sections including the one just written
+ tempForAssertions = new byte[section.getLayout().getEndOfFile()];
+ for (int j = 0; j < section.getLayout().getEndOfFile(); j++) {
+ tempForAssertions[j] = outputSoFar[j];
+ }
+ }
+
+ offset = section.getLayout().getEndOfFile();
+ sections.add(section);
+ fileTiming.end();
+ timings.add(fileTiming);
+ }
+ merger.add(timings);
+ merger.end();
+
+ ByteBufferResult result =
+ new ByteBufferResult(
+ dexOutputBuffer.stealByteBuffer(),
+ sections.get(sections.size() - 1).getLayout().getEndOfFile());
+ ByteDataView data =
+ new ByteDataView(result.buffer.array(), result.buffer.arrayOffset(), result.length);
+ // TODO(b/249922554): Add timing of passing to consumer.
+ if (consumer instanceof DexFilePerClassFileConsumer) {
+ assert false;
+ } else {
+ ((DexIndexedConsumer) consumer).accept(0, data, Sets.newIdentityHashSet(), options.reporter);
+ }
+ }
+
+ private DexContainerSection writeVirtualFileSection(
+ VirtualFile virtualFile,
+ Timing timing,
+ List<DexString> forcedStrings,
+ int offset,
+ DexOutputBuffer outputBuffer,
+ boolean last) {
+ if (virtualFile.isEmpty()) {
+ return null;
+ }
+ printItemUseInfo(virtualFile);
+
+ timing.begin("Reindex for lazy strings");
+ ObjectToOffsetMapping objectMapping = virtualFile.getObjectMapping();
+ objectMapping.computeAndReindexForLazyDexStrings(forcedStrings);
+ timing.end();
+
+ timing.begin("Write bytes");
+ DexContainerSection section =
+ writeDexFile(objectMapping, outputBuffer, virtualFile, timing, offset, last);
+ timing.end();
+ return section;
+ }
+
+ protected DexContainerSection writeDexFile(
+ ObjectToOffsetMapping objectMapping,
+ DexOutputBuffer dexOutputBuffer,
+ VirtualFile virtualFile,
+ Timing timing,
+ int offset,
+ boolean includeStringData) {
+ FileWriter fileWriter =
+ new FileWriter(
+ appView,
+ dexOutputBuffer,
+ objectMapping,
+ getDesugaredLibraryCodeToKeep(),
+ virtualFile,
+ includeStringData);
+ // Collect the non-fixed sections.
+ timing.time("collect", fileWriter::collect);
+ // Generate and write the bytes.
+ return timing.time("generate", () -> fileWriter.generate(offset));
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
index 08f8cad..e552456 100644
--- a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
+++ b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
@@ -39,7 +39,7 @@
if (byteBuffer.remaining() < bytes) {
int newSize = byteBuffer.capacity() + Math.max(byteBuffer.capacity(), bytes * 2);
CompatByteBuffer newBuffer = allocateByteBuffer(newSize);
- System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, position());
+ System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, byteBuffer.capacity());
newBuffer.position(byteBuffer.position());
freeByteBuffer(byteBuffer);
byteBuffer = newBuffer;
@@ -126,6 +126,14 @@
byteBuffer.putInt(anInteger);
}
+ public boolean assertZero() {
+ int pos = byteBuffer.position();
+ int i = byteBuffer.getInt();
+ assert i == 0;
+ byteBuffer.position(pos);
+ return true;
+ }
+
/**
* Moves the position in the bytebuffer forward until it is aligned.
*
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index a6f6a52..9ddc2d2 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -84,7 +84,7 @@
public final CompatByteBuffer buffer;
public final int length;
- private ByteBufferResult(CompatByteBuffer buffer, int length) {
+ protected ByteBufferResult(CompatByteBuffer buffer, int length) {
this.buffer = buffer;
this.length = length;
}
@@ -98,6 +98,7 @@
private final MixedSectionOffsets mixedSectionOffsets;
private final CodeToKeep desugaredLibraryCodeToKeep;
private final VirtualFile virtualFile;
+ private final boolean includeStringData;
public FileWriter(
AppView<?> appView,
@@ -105,20 +106,41 @@
ObjectToOffsetMapping mapping,
CodeToKeep desugaredLibraryCodeToKeep,
VirtualFile virtualFile) {
+ this(
+ appView,
+ new DexOutputBuffer(provider),
+ mapping,
+ desugaredLibraryCodeToKeep,
+ virtualFile,
+ true);
+ }
+
+ public FileWriter(
+ AppView<?> appView,
+ DexOutputBuffer dexOutputBuffer,
+ ObjectToOffsetMapping mapping,
+ CodeToKeep desugaredLibraryCodeToKeep,
+ VirtualFile virtualFile,
+ boolean includeStringData) {
this.appView = appView;
this.graphLens = appView.graphLens();
this.mapping = mapping;
this.options = appView.options();
- this.dest = new DexOutputBuffer(provider);
+ this.dest = dexOutputBuffer;
this.mixedSectionOffsets = new MixedSectionOffsets(options);
this.desugaredLibraryCodeToKeep = desugaredLibraryCodeToKeep;
this.virtualFile = virtualFile;
+ this.includeStringData = includeStringData;
}
private NamingLens getNamingLens() {
return appView.getNamingLens();
}
+ public MixedSectionOffsets getMixedSectionOffsets() {
+ return mixedSectionOffsets;
+ }
+
public static void writeEncodedAnnotation(
DexEncodedAnnotation annotation, DexOutputBuffer dest, ObjectToOffsetMapping mapping) {
if (Log.ENABLED) {
@@ -158,14 +180,43 @@
return this;
}
+ public static class DexContainerSection {
+ private final FileWriter writer;
+ private final DexOutputBuffer buffer;
+ private final Layout layout;
+
+ public DexContainerSection(FileWriter writer, DexOutputBuffer buffer, Layout layout) {
+ this.writer = writer;
+ this.buffer = buffer;
+ this.layout = layout;
+ }
+
+ public FileWriter getFileWriter() {
+ return writer;
+ }
+
+ public DexOutputBuffer getBuffer() {
+ return buffer;
+ }
+
+ public Layout getLayout() {
+ return layout;
+ }
+ }
+
public ByteBufferResult generate() {
+ DexContainerSection res = generate(0);
+ return new ByteBufferResult(res.getBuffer().stealByteBuffer(), res.getLayout().getEndOfFile());
+ }
+
+ public DexContainerSection generate(int offset) {
// Check restrictions on interface methods.
checkInterfaceMethods();
// Check restriction on the names of fields, methods and classes
assert verifyNames();
- Layout layout = Layout.from(mapping);
+ Layout layout = Layout.from(mapping, offset, includeStringData);
layout.setCodesOffset(layout.dataSectionOffset);
// Sort the codes first, as their order might impact size due to alignment constraints.
@@ -205,10 +256,14 @@
mixedSectionLayoutStrategy.getTypeListLayout(),
layout::alreadySetOffset,
this::writeTypeList);
- writeItems(
- mixedSectionLayoutStrategy.getStringDataLayout(),
- layout::setStringDataOffsets,
- this::writeStringData);
+ if (includeStringData) {
+ writeItems(
+ mixedSectionLayoutStrategy.getStringDataLayout(),
+ layout::setStringDataOffsets,
+ this::writeStringData);
+ } else {
+ layout.stringDataOffsets = 0; // Empty string data section.
+ }
writeItems(
mixedSectionLayoutStrategy.getAnnotationLayout(),
layout::setAnnotationsOffset,
@@ -243,8 +298,12 @@
layout.setEndOfFile(dest.position());
// Now that we have all mixedSectionOffsets, lets write the indexed items.
- dest.moveTo(Constants.TYPE_HEADER_ITEM_SIZE);
- writeFixedSectionItems(mapping.getStrings(), layout.stringIdsOffset, this::writeStringItem);
+ dest.moveTo(layout.headerOffset + Constants.TYPE_HEADER_ITEM_SIZE);
+ if (includeStringData) {
+ writeFixedSectionItems(mapping.getStrings(), layout.stringIdsOffset, this::writeStringItem);
+ } else {
+ assert layout.stringIdsOffset == layout.typeIdsOffset;
+ }
writeFixedSectionItems(mapping.getTypes(), layout.typeIdsOffset, this::writeTypeItem);
writeFixedSectionItems(mapping.getProtos(), layout.protoIdsOffset, this::writeProtoItem);
writeFixedSectionItems(mapping.getFields(), layout.fieldIdsOffset, this::writeFieldItem);
@@ -260,7 +319,7 @@
writeChecksum(layout);
// Wrap backing buffer with actual length.
- return new ByteBufferResult(dest.stealByteBuffer(), layout.getEndOfFile());
+ return new DexContainerSection(this, dest, layout);
}
private void checkInterfaceMethods() {
@@ -759,8 +818,11 @@
mixedSectionOffsets.getDebugInfos().size());
size += writeMapItem(Constants.TYPE_TYPE_LIST, layout.getTypeListsOffset(),
mixedSectionOffsets.getTypeLists().size());
- size += writeMapItem(Constants.TYPE_STRING_DATA_ITEM, layout.getStringDataOffsets(),
- mixedSectionOffsets.getStringData().size());
+ size +=
+ writeMapItem(
+ Constants.TYPE_STRING_DATA_ITEM,
+ layout.getStringDataOffsets(),
+ layout.getStringDataOffsets() == 0 ? 0 : mixedSectionOffsets.getStringData().size());
size += writeMapItem(Constants.TYPE_ANNOTATION_ITEM, layout.getAnnotationsOffset(),
mixedSectionOffsets.getAnnotations().size());
size += writeMapItem(Constants.TYPE_CLASS_DATA_ITEM, layout.getClassDataOffset(),
@@ -784,16 +846,22 @@
dest.forward(size * Constants.TYPE_MAP_LIST_ITEM_SIZE);
}
+ private byte[] dexVersionBytes() {
+ if (options.testing.dexContainerExperiment) {
+ return DexVersion.V40.getBytes();
+ }
+ return options.testing.forceDexVersionBytes != null
+ ? options.testing.forceDexVersionBytes
+ : DexVersion.getDexVersion(options.getMinApiLevel()).getBytes();
+ }
+
private void writeHeader(Layout layout) {
- dest.moveTo(0);
+ dest.moveTo(layout.headerOffset);
dest.putBytes(Constants.DEX_FILE_MAGIC_PREFIX);
- dest.putBytes(
- options.testing.forceDexVersionBytes != null
- ? options.testing.forceDexVersionBytes
- : DexVersion.getDexVersion(options.getMinApiLevel()).getBytes());
+ dest.putBytes(dexVersionBytes());
dest.putByte(Constants.DEX_FILE_MAGIC_SUFFIX);
// Leave out checksum and signature for now.
- dest.moveTo(Constants.FILE_SIZE_OFFSET);
+ dest.moveTo(layout.headerOffset + Constants.FILE_SIZE_OFFSET);
dest.putInt(layout.getEndOfFile());
dest.putInt(Constants.TYPE_HEADER_ITEM_SIZE);
dest.putInt(Constants.ENDIAN_CONSTANT);
@@ -826,9 +894,11 @@
private void writeSignature(Layout layout) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-1");
- md.update(dest.asArray(), Constants.FILE_SIZE_OFFSET,
- layout.getEndOfFile() - Constants.FILE_SIZE_OFFSET);
- md.digest(dest.asArray(), Constants.SIGNATURE_OFFSET, 20);
+ md.update(
+ dest.asArray(),
+ layout.headerOffset + Constants.FILE_SIZE_OFFSET,
+ layout.getEndOfFile() - layout.headerOffset - Constants.FILE_SIZE_OFFSET);
+ md.digest(dest.asArray(), layout.headerOffset + Constants.SIGNATURE_OFFSET, 20);
} catch (Exception e) {
throw new RuntimeException(e);
}
@@ -836,9 +906,11 @@
private void writeChecksum(Layout layout) {
Adler32 adler = new Adler32();
- adler.update(dest.asArray(), Constants.SIGNATURE_OFFSET,
- layout.getEndOfFile() - Constants.SIGNATURE_OFFSET);
- dest.moveTo(Constants.CHECKSUM_OFFSET);
+ adler.update(
+ dest.asArray(),
+ layout.headerOffset + Constants.SIGNATURE_OFFSET,
+ layout.getEndOfFile() - layout.headerOffset - Constants.SIGNATURE_OFFSET);
+ dest.moveTo(layout.headerOffset + Constants.CHECKSUM_OFFSET);
dest.putInt((int) adler.getValue());
}
@@ -847,11 +919,12 @@
return (value + mask) & ~mask;
}
- private static class Layout {
+ public static class Layout {
private static final int NOT_SET = -1;
// Fixed size constant pool sections
+ final int headerOffset;
final int stringIdsOffset;
final int typeIdsOffset;
final int protoIdsOffset;
@@ -878,6 +951,7 @@
private int endOfFile = NOT_SET;
private Layout(
+ int headerOffset,
int stringIdsOffset,
int typeIdsOffset,
int protoIdsOffset,
@@ -887,6 +961,7 @@
int callSiteIdsOffset,
int methodHandleIdsOffset,
int dataSectionOffset) {
+ this.headerOffset = headerOffset;
this.stringIdsOffset = stringIdsOffset;
this.typeIdsOffset = typeIdsOffset;
this.protoIdsOffset = protoIdsOffset;
@@ -907,10 +982,17 @@
}
static Layout from(ObjectToOffsetMapping mapping) {
- int offset = 0;
+ return from(mapping, 0, true);
+ }
+
+ static Layout from(ObjectToOffsetMapping mapping, int offset, boolean includeStringData) {
return new Layout(
- offset = Constants.TYPE_HEADER_ITEM_SIZE,
- offset += mapping.getStrings().size() * Constants.TYPE_STRING_ID_ITEM_SIZE,
+ offset,
+ offset += Constants.TYPE_HEADER_ITEM_SIZE,
+ offset +=
+ includeStringData
+ ? mapping.getStrings().size() * Constants.TYPE_STRING_ID_ITEM_SIZE
+ : 0,
offset += mapping.getTypes().size() * Constants.TYPE_TYPE_ID_ITEM_SIZE,
offset += mapping.getProtos().size() * Constants.TYPE_PROTO_ID_ITEM_SIZE,
offset += mapping.getFields().size() * Constants.TYPE_FIELD_ID_ITEM_SIZE,
@@ -1049,6 +1131,95 @@
public void setEndOfFile(int endOfFile) {
this.endOfFile = endOfFile;
}
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder();
+ if (false) {
+ builder.append("headerOffset: ").append(headerOffset).append("\n");
+ builder.append("stringIdsOffset: ").append(stringIdsOffset).append("\n");
+ builder.append("typeIdsOffset: ").append(typeIdsOffset).append("\n");
+ builder.append("protoIdsOffset: ").append(protoIdsOffset).append("\n");
+ builder.append("fieldIdsOffset: ").append(fieldIdsOffset).append("\n");
+ builder.append("methodIdsOffset: ").append(methodIdsOffset).append("\n");
+ builder.append("classDefsOffset: ").append(classDefsOffset).append("\n");
+ builder.append("callSiteIdsOffset: ").append(callSiteIdsOffset).append("\n");
+ builder.append("methodHandleIdsOffset: ").append(methodHandleIdsOffset).append("\n");
+ builder.append("dataSectionOffset: ").append(dataSectionOffset).append("\n");
+
+ // Mixed size sections
+ builder.append("codesOffset: ").append(codesOffset).append("\n");
+ builder.append("debugInfosOffset: ").append(debugInfosOffset).append("\n");
+
+ builder.append("typeListsOffset: ").append(typeListsOffset).append("\n");
+ builder.append("stringDataOffsets: ").append(stringDataOffsets).append("\n");
+ builder.append("annotationsOffset: ").append(annotationsOffset).append("\n");
+ builder.append("annotationSetsOffset: ").append(annotationSetsOffset).append("\n");
+ builder
+ .append("annotationSetRefListsOffset: ")
+ .append(annotationSetRefListsOffset)
+ .append("\n");
+ builder
+ .append("annotationDirectoriesOffset: ")
+ .append(annotationDirectoriesOffset)
+ .append("\n");
+ builder.append("classDataOffset: ").append(classDataOffset).append("\n");
+ builder.append("encodedArraysOffset: ").append(encodedArraysOffset).append("\n");
+ builder.append("mapOffset: ").append(mapOffset).append("\n");
+ builder.append("endOfFile: ").append(endOfFile).append("\n");
+ } else {
+ builder.append("Header: ").append(stringIdsOffset - headerOffset).append("\n");
+ builder.append("StringIds: ").append(typeIdsOffset - stringIdsOffset).append("\n");
+ builder.append("typeIds: ").append(protoIdsOffset - typeIdsOffset).append("\n");
+ builder.append("protoIds: ").append(fieldIdsOffset - protoIdsOffset).append("\n");
+ builder.append("fieldIds: ").append(methodIdsOffset - fieldIdsOffset).append("\n");
+ builder.append("methodIds: ").append(classDefsOffset - methodIdsOffset).append("\n");
+ builder.append("classDefs: ").append(callSiteIdsOffset - classDefsOffset).append("\n");
+ builder
+ .append("callSiteIds: ")
+ .append(methodHandleIdsOffset - callSiteIdsOffset)
+ .append("\n");
+ builder
+ .append("methodHandleIds: ")
+ .append(dataSectionOffset - methodHandleIdsOffset)
+ .append("\n");
+
+ // Mixed size sections
+ builder.append("code: ").append(debugInfosOffset - codesOffset).append("\n");
+ builder.append("debugInfo: ").append(typeListsOffset - debugInfosOffset).append("\n");
+
+ builder
+ .append("typeList: ")
+ .append(
+ (stringDataOffsets > 0 ? stringDataOffsets : annotationsOffset) - typeListsOffset)
+ .append("\n");
+ builder
+ .append("stringData: ")
+ .append(stringDataOffsets > 0 ? annotationsOffset - stringDataOffsets : 0)
+ .append("\n");
+ builder.append("annotations: ").append(classDataOffset - annotationsOffset).append("\n");
+ builder.append("classData: ").append(encodedArraysOffset - classDataOffset).append("\n");
+ builder
+ .append("encodedArrays: ")
+ .append(mapOffset - annotationSetRefListsOffset)
+ .append("\n");
+ builder
+ .append("annotationSets: ")
+ .append(annotationSetRefListsOffset - annotationSetsOffset)
+ .append("\n");
+ builder
+ .append("annotationSetRefLists: ")
+ .append(annotationDirectoriesOffset - annotationSetRefListsOffset)
+ .append("\n");
+ builder
+ .append("annotationDirectories: ")
+ .append(mapOffset - annotationDirectoriesOffset)
+ .append("\n");
+ builder.append("map: ").append(endOfFile - mapOffset).append("\n");
+ builder.append("endOfFile: ").append(endOfFile).append("\n");
+ }
+ return builder.toString();
+ }
}
/**
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index f6b057a..436f365 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -203,11 +203,20 @@
AppView<?> appView,
int lazyDexStringsCount,
Timing timing) {
+ computeMapping(appView, lazyDexStringsCount, timing, null);
+ }
+
+ public void computeMapping(
+ AppView<?> appView,
+ int lazyDexStringsCount,
+ Timing timing,
+ ObjectToOffsetMapping sharedMapping) {
assert transaction.isEmpty();
assert objectMapping == null;
objectMapping =
new ObjectToOffsetMapping(
appView,
+ sharedMapping,
transaction.rewriter,
indexedItems.classes,
indexedItems.protos,
@@ -663,6 +672,10 @@
return strings.add(string);
}
+ public boolean addStrings(Collection<DexString> additionalStrings) {
+ return strings.addAll(additionalStrings);
+ }
+
@Override
public boolean addProto(DexProto proto) {
return protos.add(proto);
@@ -691,6 +704,10 @@
int getNumberOfFields() {
return fields.size();
}
+
+ Collection<DexString> getStrings() {
+ return strings;
+ }
}
public static class IndexedItemTransaction implements IndexedItemCollection {
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
index 6173bef..028617e 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
@@ -53,6 +53,7 @@
public ObjectToOffsetMapping(
AppView<?> appView,
+ ObjectToOffsetMapping sharedMapping,
LensCodeRewriterUtils lensCodeRewriter,
Collection<DexProgramClass> classes,
Collection<DexProto> protos,
@@ -80,9 +81,14 @@
this.initClassLens = appView.initClassLens();
this.lensCodeRewriter = lensCodeRewriter;
timing.begin("Sort strings");
- this.strings =
- createSortedMap(
- strings, DexString::compareTo, this::setFirstJumboString, lazyDexStringsCount);
+ if (sharedMapping == null) {
+ this.strings =
+ createSortedMap(
+ strings, DexString::compareTo, this::setFirstJumboString, lazyDexStringsCount);
+ } else {
+ this.strings = sharedMapping.strings;
+ this.firstJumboString = sharedMapping.firstJumboString;
+ }
CompareToVisitor visitor =
new CompareToVisitorWithStringTable(namingLens, this.strings::getInt);
timing.end();
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNaming.java b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
index 6083e8b..138e738 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
@@ -18,7 +18,7 @@
abstract class Builder {
- public abstract Builder addMemberEntry(MemberNaming entry, Signature residualSignature);
+ public abstract Builder addMemberEntry(MemberNaming entry);
public abstract ClassNaming build();
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
index 93a5666..cbfb5e3 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
@@ -19,6 +19,7 @@
import com.google.common.collect.ImmutableMap;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -55,7 +56,7 @@
}
@Override
- public ClassNaming.Builder addMemberEntry(MemberNaming entry, Signature residualSignature) {
+ public ClassNaming.Builder addMemberEntry(MemberNaming entry) {
// Unlike {@link ClassNamingForNameMapper.Builder#addMemberEntry},
// the key is original signature.
if (entry.isMethodNaming()) {
@@ -170,32 +171,26 @@
public MemberNaming lookup(Signature renamedSignature) {
// As the key is inverted, this looks a lot like
// {@link ClassNamingForNameMapper#lookupByOriginalSignature}.
- if (renamedSignature.kind() == SignatureKind.METHOD) {
- for (MemberNaming memberNaming : methodMembers.values()) {
- if (memberNaming.getResidualSignatureInternal().equals(renamedSignature)) {
- return memberNaming;
- }
+ Collection<MemberNaming> memberNamings =
+ renamedSignature.kind() == SignatureKind.METHOD
+ ? methodMembers.values()
+ : fieldMembers.values();
+ for (MemberNaming memberNaming : memberNamings) {
+ if (memberNaming.getResidualSignature().equals(renamedSignature)) {
+ return memberNaming;
}
- return null;
- } else {
- assert renamedSignature.kind() == SignatureKind.FIELD;
- for (MemberNaming memberNaming : fieldMembers.values()) {
- if (memberNaming.getResidualSignatureInternal().equals(renamedSignature)) {
- return memberNaming;
- }
- }
- return null;
}
+ return null;
}
@Override
public MemberNaming lookupByOriginalSignature(Signature original) {
// As the key is inverted, this looks a lot like {@link ClassNamingForNameMapper#lookup}.
if (original.kind() == SignatureKind.METHOD) {
- return methodMembers.get(original);
+ return methodMembers.get(original.asMethodSignature());
} else {
assert original.kind() == SignatureKind.FIELD;
- return fieldMembers.get(original);
+ return fieldMembers.get(original.asFieldSignature());
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 8fb8ae6..0f09fdf 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming;
+import static com.android.tools.r8.naming.MappedRangeUtils.addAllInlineFramesUntilOutermostCaller;
+
import com.android.tools.r8.naming.MemberNaming.FieldSignature;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.naming.MemberNaming.Signature;
@@ -11,9 +13,11 @@
import com.android.tools.r8.naming.mappinginformation.OutlineCallsiteMappingInformation;
import com.android.tools.r8.naming.mappinginformation.RewriteFrameMappingInformation;
import com.android.tools.r8.utils.ChainableStringConsumer;
+import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.ThrowingConsumer;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Collection;
@@ -59,11 +63,11 @@
}
@Override
- public ClassNaming.Builder addMemberEntry(MemberNaming entry, Signature residualSignature) {
+ public ClassNaming.Builder addMemberEntry(MemberNaming entry) {
if (entry.isMethodNaming()) {
- methodMembers.put(residualSignature.asMethodSignature(), entry);
+ methodMembers.put(entry.getResidualSignature().asMethodSignature(), entry);
} else {
- fieldMembers.put(residualSignature.asFieldSignature(), entry);
+ fieldMembers.put(entry.getResidualSignature().asFieldSignature(), entry);
mappedFieldNamingsByName
.computeIfAbsent(entry.getRenamedName(), ignored -> new ArrayList<>())
.add(entry);
@@ -218,6 +222,48 @@
public int hashCode() {
return mappedRanges.hashCode();
}
+
+ public List<MappedRangesOfName> partitionOnMethodSignature() {
+ if (mappedRanges.size() <= 1) {
+ return Collections.singletonList(this);
+ }
+ List<MappedRangesOfName> partitionedMappings = new ArrayList<>();
+ int index = 0;
+ List<MappedRange> currentMappedRanges = new ArrayList<>();
+ index = addAllInlineFramesUntilOutermostCaller(mappedRanges, index, currentMappedRanges);
+ // Do a fast check to see if the last one is the same signature as the first one.
+ if (ListUtils.last(currentMappedRanges)
+ .getOriginalSignature()
+ .equals(ListUtils.last(mappedRanges).getOriginalSignature())) {
+ return Collections.singletonList(this);
+ }
+ // Otherwise the signature changes which means we have overloads.
+ while (index < mappedRanges.size()) {
+ List<MappedRange> newMappedRanges = new ArrayList<>();
+ index = addAllInlineFramesUntilOutermostCaller(mappedRanges, index, newMappedRanges);
+ if (!ListUtils.last(currentMappedRanges)
+ .getOriginalSignature()
+ .equals(ListUtils.last(newMappedRanges).getOriginalSignature())) {
+ partitionedMappings.add(new MappedRangesOfName(currentMappedRanges));
+ currentMappedRanges = new ArrayList<>();
+ }
+ currentMappedRanges.addAll(newMappedRanges);
+ }
+ partitionedMappings.add(new MappedRangesOfName(currentMappedRanges));
+ return partitionedMappings;
+ }
+
+ public MemberNaming getMemberNaming(
+ ClassNamingForNameMapper classNamingForNameMapper, boolean hasMultipleResults) {
+ MappedRange lastMappedRange = ListUtils.last(mappedRanges);
+ if (hasMultipleResults) {
+ return null;
+ }
+ MethodSignature signature = lastMappedRange.getResidualSignature();
+ MemberNaming memberNaming = classNamingForNameMapper.methodMembers.get(signature);
+ assert memberNaming != null;
+ return memberNaming;
+ }
}
static Builder builder(
@@ -425,7 +471,7 @@
mappedRangesSorted.sort(Comparator.comparingInt(range -> range.sequenceNumber));
for (MappedRange range : mappedRangesSorted) {
consumer.accept(" ").accept(range.toString()).accept("\n");
- for (MappingInformation info : range.additionalMappingInfo) {
+ for (MappingInformation info : range.getAdditionalMappingInformation()) {
consumer.accept(" # ").accept(info.serialize()).accept("\n");
}
}
@@ -499,13 +545,19 @@
private MethodSignature residualSignature = null;
+ private boolean hasComputedHashCode = false;
+
/**
* The sole purpose of {@link #sequenceNumber} is to preserve the order of members read from a
* Proguard-map.
*/
private final int sequenceNumber = getNextSequenceNumber();
- private List<MappingInformation> additionalMappingInfo = EMPTY_MAPPING_INFORMATION;
+ /**
+ * We never emit member namings for methods so mapped ranges has to account for both positional
+ * and referential mapping information.
+ */
+ private List<MappingInformation> additionalMappingInformation = EMPTY_MAPPING_INFORMATION;
MappedRange(
Range minifiedRange, MethodSignature signature, Range originalRange, String renamedName) {
@@ -522,40 +574,17 @@
public void addMappingInformation(
MappingInformation info, Consumer<MappingInformation> onProhibitedAddition) {
- if (additionalMappingInfo == EMPTY_MAPPING_INFORMATION) {
- additionalMappingInfo = new ArrayList<>();
+ if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+ additionalMappingInformation = new ArrayList<>();
}
- for (MappingInformation existing : additionalMappingInfo) {
- if (!existing.allowOther(info)) {
- onProhibitedAddition.accept(existing);
- return;
- }
- }
- additionalMappingInfo.add(info);
+ MappingInformation.addMappingInformation(
+ additionalMappingInformation, info, onProhibitedAddition);
}
- public boolean isCompilerSynthesized() {
- for (MappingInformation info : additionalMappingInfo) {
- if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
- return true;
- }
- }
- return false;
- }
-
- public boolean isOutlineFrame() {
- for (MappingInformation info : additionalMappingInfo) {
- if (info.isOutlineMappingInformation()) {
- return true;
- }
- }
- return false;
- }
-
- public <T> List<T> filter(
+ private <T> List<T> filter(
Predicate<MappingInformation> predicate, Function<MappingInformation, T> mapper) {
ImmutableList.Builder<T> builder = ImmutableList.builder();
- for (MappingInformation mappingInformation : additionalMappingInfo) {
+ for (MappingInformation mappingInformation : additionalMappingInformation) {
if (predicate.test(mappingInformation)) {
builder.add(mapper.apply(mappingInformation));
}
@@ -607,20 +636,41 @@
return signature;
}
- @Override
- public boolean hasResidualSignature() {
- return residualSignature != null;
+ public boolean isCompilerSynthesized() {
+ for (MappingInformation info : additionalMappingInformation) {
+ if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public boolean isOutlineFrame() {
+ for (MappingInformation info : additionalMappingInformation) {
+ if (info.isOutlineMappingInformation()) {
+ return true;
+ }
+ }
+ return false;
}
@Override
- public MethodSignature getResidualSignatureInternal() {
- return residualSignature;
+ public boolean hasResidualSignatureMappingInformation() {
+ return Iterables.any(
+ additionalMappingInformation, MappingInformation::isResidualSignatureMappingInformation);
+ }
+
+ public void setResidualSignatureInternal(MethodSignature signature) {
+ assert !hasComputedHashCode;
+ this.residualSignature = signature;
}
@Override
- public void setResidualSignatureInternal(Signature residualSignature) {
- assert residualSignature.isMethodSignature();
- this.residualSignature = residualSignature.asMethodSignature();
+ public MethodSignature getResidualSignature() {
+ if (residualSignature != null) {
+ return residualSignature;
+ }
+ return signature.asRenamed(renamedName).asMethodSignature();
}
public int getLastPositionOfOriginalRange() {
@@ -662,7 +712,8 @@
&& Objects.equals(originalRange, that.originalRange)
&& signature.equals(that.signature)
&& renamedName.equals(that.renamedName)
- && Objects.equals(residualSignature, that.residualSignature);
+ && Objects.equals(residualSignature, that.residualSignature)
+ && Objects.equals(additionalMappingInformation, that.additionalMappingInformation);
}
@Override
@@ -673,11 +724,13 @@
result = 31 * result + signature.hashCode();
result = 31 * result + renamedName.hashCode();
result = 31 * result + Objects.hashCode(residualSignature);
+ result = 31 * result + Objects.hashCode(additionalMappingInformation);
+ hasComputedHashCode = true;
return result;
}
- public List<MappingInformation> getAdditionalMappingInfo() {
- return Collections.unmodifiableList(additionalMappingInfo);
+ public List<MappingInformation> getAdditionalMappingInformation() {
+ return Collections.unmodifiableList(additionalMappingInformation);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java b/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
index 5b3e838..cc7f927 100644
--- a/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
+++ b/src/main/java/com/android/tools/r8/naming/ComposingBuilder.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.naming;
+import static com.android.tools.r8.naming.MappedRangeUtils.addAllInlineFramesUntilOutermostCaller;
+import static com.android.tools.r8.naming.MappedRangeUtils.isInlineMappedRange;
import static com.android.tools.r8.utils.FunctionUtils.ignoreArgument;
import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
@@ -595,7 +597,8 @@
// Register mapping information that is dependent on the residual naming to allow updating
// later on.
for (MappedRange mappedRange : mappedRangesForThisInterval) {
- for (MappingInformation mappingInformation : mappedRange.getAdditionalMappingInfo()) {
+ for (MappingInformation mappingInformation :
+ mappedRange.getAdditionalMappingInformation()) {
if (mappingInformation.isRewriteFrameMappingInformation()) {
RewriteFrameMappingInformation rewriteFrameMappingInformation =
mappingInformation.asRewriteFrameMappingInformation();
@@ -631,16 +634,6 @@
seenMappedRanges);
}
- private int addAllInlineFramesUntilOutermostCaller(
- List<MappedRange> mappedRanges, int index, List<MappedRange> seenMappedRanges) {
- assert index < mappedRanges.size();
- while (isInlineMappedRange(mappedRanges, index)) {
- seenMappedRanges.add(mappedRanges.get(index++));
- }
- seenMappedRanges.add(mappedRanges.get(index++));
- return index;
- }
-
private List<MappedRange> composeMappedRangesForMethod(
List<MappedRange> existingRanges, List<MappedRange> newRanges)
throws MappingComposeException {
@@ -687,8 +680,8 @@
new MappedRange(
null, lastExistingRange.signature, originalRange.get(), newRange.renamedName);
composeMappingInformation(
- newComposedRange.getAdditionalMappingInfo(),
- lastExistingRange.getAdditionalMappingInfo(),
+ newComposedRange.getAdditionalMappingInformation(),
+ lastExistingRange.getAdditionalMappingInformation(),
info -> newComposedRange.addMappingInformation(info, ConsumerUtils.emptyConsumer()));
newComposedRanges.add(newComposedRange);
} else {
@@ -789,7 +782,7 @@
newOriginalRange,
lastExistingMappedRange.renamedName);
nonExistingMappedRange.setResidualSignatureInternal(
- lastExistingRange.getResidualSignatureInternal());
+ lastExistingRange.getResidualSignature());
lastExistingMappedRange = nonExistingMappedRange;
existingMappedRanges = Collections.singletonList(nonExistingMappedRange);
position += (endOriginalPosition - startOriginalPosition) - 1;
@@ -938,7 +931,7 @@
newMappedRange.renamedName);
List<MappingInformation> mappingInformationToCompose = new ArrayList<>();
existingMappedRange
- .getAdditionalMappingInfo()
+ .getAdditionalMappingInformation()
.forEach(
info -> {
if (info.isOutlineMappingInformation()) {
@@ -952,7 +945,7 @@
}
});
composeMappingInformation(
- computedRange.getAdditionalMappingInfo(),
+ computedRange.getAdditionalMappingInformation(),
mappingInformationToCompose,
info -> computedRange.addMappingInformation(info, ConsumerUtils.emptyConsumer()));
newComposedRanges.add(computedRange);
@@ -989,16 +982,6 @@
});
}
- private boolean isInlineMappedRange(List<MappedRange> mappedRanges, int index) {
- // We are comparing against the next entry so we need a buffer of one.
- if (index + 1 >= mappedRanges.size()) {
- return false;
- }
- MappedRange mappedRange = mappedRanges.get(index);
- return mappedRange.minifiedRange != null
- && mappedRange.minifiedRange.equals(mappedRanges.get(index + 1).minifiedRange);
- }
-
public void write(ChainableStringConsumer consumer) {
consumer.accept(originalName).accept(" -> ").accept(renamedName).accept(":\n");
additionalMappingInfo.forEach(info -> consumer.accept("# " + info.serialize()).accept("\n"));
@@ -1018,7 +1001,7 @@
methodsWithoutPosition.forEach(
(ignored, mapped) -> {
consumer.accept(INDENTATION).accept(mapped.toString()).accept("\n");
- for (MappingInformation info : mapped.getAdditionalMappingInfo()) {
+ for (MappingInformation info : mapped.getAdditionalMappingInformation()) {
consumer.accept(INDENTATION).accept("# ").accept(info.serialize()).accept("\n");
}
});
@@ -1043,7 +1026,7 @@
.forEach(
mappedRange -> {
consumer.accept(INDENTATION).accept(mappedRange.toString()).accept("\n");
- for (MappingInformation info : mappedRange.getAdditionalMappingInfo()) {
+ for (MappingInformation info : mappedRange.getAdditionalMappingInformation()) {
consumer.accept(INDENTATION).accept("# ").accept(info.serialize()).accept("\n");
}
});
diff --git a/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java b/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java
new file mode 100644
index 0000000..7dff280
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/MappedRangeUtils.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.naming;
+
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import java.util.List;
+
+public class MappedRangeUtils {
+
+ static int addAllInlineFramesUntilOutermostCaller(
+ List<MappedRange> mappedRanges, int index, List<MappedRange> listToAdd) {
+ assert index < mappedRanges.size();
+ while (isInlineMappedRange(mappedRanges, index)) {
+ listToAdd.add(mappedRanges.get(index++));
+ }
+ listToAdd.add(mappedRanges.get(index++));
+ return index;
+ }
+
+ static boolean isInlineMappedRange(List<MappedRange> mappedRanges, int index) {
+ // We are comparing against the next entry so we need a buffer of one.
+ if (index + 1 >= mappedRanges.size()) {
+ return false;
+ }
+ MappedRange mappedRange = mappedRanges.get(index);
+ return mappedRange.minifiedRange != null
+ && mappedRange.minifiedRange.equals(mappedRanges.get(index + 1).minifiedRange);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java b/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
index 7e7bcd0..77e145b 100644
--- a/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
+++ b/src/main/java/com/android/tools/r8/naming/MappingWithResidualInfo.java
@@ -13,19 +13,16 @@
Signature getOriginalSignature();
- boolean hasResidualSignature();
+ boolean hasResidualSignatureMappingInformation();
- Signature getResidualSignatureInternal();
+ Signature getResidualSignature();
- void setResidualSignatureInternal(Signature signature);
-
+ /** Should be removed when R8 emits residual information for alpha renamed signatures. */
+ @Deprecated()
default Signature computeResidualSignature(Function<String, String> typeNameMapper) {
- if (hasResidualSignature()) {
- return getResidualSignatureInternal();
+ if (hasResidualSignatureMappingInformation()) {
+ return getResidualSignature();
}
- Signature residualSignature =
- getOriginalSignature().computeResidualSignature(getRenamedName(), typeNameMapper);
- setResidualSignatureInternal(residualSignature);
- return residualSignature;
+ return getOriginalSignature().computeResidualSignature(getRenamedName(), typeNameMapper);
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 043bb4c..12606ff 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -13,6 +13,8 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.android.tools.r8.position.Position;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
@@ -21,12 +23,16 @@
import com.android.tools.r8.utils.CollectionUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.Iterables;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Objects;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
import java.util.function.Function;
import org.objectweb.asm.Type;
@@ -37,6 +43,9 @@
*/
public class MemberNaming implements MappingWithResidualInfo {
+ private static final List<ReferentialMappingInformation> EMPTY_MAPPING_INFORMATION =
+ Collections.emptyList();
+
@Override
public boolean equals(Object o) {
if (this == o) {
@@ -45,55 +54,41 @@
if (!(o instanceof MemberNaming)) {
return false;
}
-
MemberNaming that = (MemberNaming) o;
- return signature.equals(that.signature)
- && renamedName.equals(that.renamedName)
- && Objects.equals(residualSignature, that.residualSignature);
+ return signature.equals(that.signature) && residualSignature.equals(that.residualSignature);
}
@Override
public int hashCode() {
int result = signature.hashCode();
- result = 31 * result + renamedName.hashCode();
- result = 31 * result + Objects.hashCode(residualSignature);
+ result = 31 * result + residualSignature.hashCode();
return result;
}
/** Original signature of the member. */
private final Signature signature;
/** Residual signature where types and names could be changed. */
- private Signature residualSignature = null;
- /**
- * Renamed name in the mapping file. This value will always be present even if the residual
- * signature is not.
- */
- private final String renamedName;
+ private final Signature residualSignature;
/** Position of the member in the file. */
private final Position position;
- public MemberNaming(Signature signature, String renamedName) {
- this(signature, renamedName, Position.UNKNOWN);
- }
+ private List<ReferentialMappingInformation> additionalMappingInformation =
+ EMPTY_MAPPING_INFORMATION;
public MemberNaming(Signature signature, Signature residualSignature) {
- this(signature, residualSignature.getName(), Position.UNKNOWN);
- this.residualSignature = residualSignature;
+ this(signature, residualSignature, Position.UNKNOWN);
}
- public MemberNaming(Signature signature, String renamedName, Position position) {
+ public MemberNaming(Signature signature, Signature residualSignature, Position position) {
this.signature = signature;
- this.renamedName = renamedName;
+ this.residualSignature = residualSignature;
this.position = position;
}
/** This is used internally in google3. */
@Deprecated
public Signature getRenamedSignature() {
- if (residualSignature != null) {
- return residualSignature;
- }
- return getOriginalSignature().asRenamed(renamedName);
+ return residualSignature;
}
@Override
@@ -106,13 +101,14 @@
}
@Override
- public boolean hasResidualSignature() {
- return residualSignature != null;
+ public boolean hasResidualSignatureMappingInformation() {
+ return Iterables.any(
+ additionalMappingInformation, MappingInformation::isResidualSignatureMappingInformation);
}
@Override
public String getRenamedName() {
- return renamedName;
+ return residualSignature.getName();
}
public boolean isMethodNaming() {
@@ -129,17 +125,50 @@
@Override
public String toString() {
- return signature.toString() + " -> " + renamedName;
+ return signature.toString() + " -> " + residualSignature.getName();
}
@Override
- public Signature getResidualSignatureInternal() {
+ public Signature getResidualSignature() {
return residualSignature;
}
- @Override
- public void setResidualSignatureInternal(Signature signature) {
- this.residualSignature = signature;
+ public void addMappingInformation(
+ ReferentialMappingInformation info, Consumer<MappingInformation> onProhibitedAddition) {
+ if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+ additionalMappingInformation = new ArrayList<>();
+ }
+ MappingInformation.addMappingInformation(
+ additionalMappingInformation, info, onProhibitedAddition);
+ }
+
+ void addAllMappingInformationInternal(List<ReferentialMappingInformation> otherInfo) {
+ if (additionalMappingInformation == EMPTY_MAPPING_INFORMATION) {
+ additionalMappingInformation = new ArrayList<>();
+ }
+ additionalMappingInformation.addAll(otherInfo);
+ }
+
+ public boolean isCompilerSynthesized() {
+ for (MappingInformation info : additionalMappingInformation) {
+ if (info.isCompilerSynthesizedMappingInformation() || info.isOutlineMappingInformation()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public boolean isOutlineFrame() {
+ for (MappingInformation info : additionalMappingInformation) {
+ if (info.isOutlineMappingInformation()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public List<ReferentialMappingInformation> getAdditionalMappingInformation() {
+ return additionalMappingInformation;
}
public abstract static class Signature {
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
index 80cc8e6..cd8bd3f 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
@@ -12,11 +12,15 @@
import com.android.tools.r8.naming.PositionRangeAllocator.NonCardinalPositionRangeAllocator;
import com.android.tools.r8.naming.mappinginformation.MapVersionMappingInformation;
import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics;
+import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation;
+import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualFieldSignatureMappingInformation;
import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualMethodSignatureMappingInformation;
import com.android.tools.r8.position.Position;
import com.android.tools.r8.utils.ArrayUtils;
import com.android.tools.r8.utils.BooleanBox;
+import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.IdentifierUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -334,14 +338,20 @@
private void parseMemberMappings(
ProguardMap.Builder mapBuilder, ClassNaming.Builder classNamingBuilder) throws IOException {
MemberNaming lastAddedNaming = null;
- MemberNaming activeMemberNaming = null;
+ // To ensure we only commit a member if we have the residual signature, we delay creating the
+ // object and have the variables out here.
+ Signature previousOriginalSignature = null;
+ String previousRenamedName = null;
+ int previousLineNumber = -1;
+ Range previousRange = null;
+ Box<Signature> currentResidualSignature = new Box<>();
+ Box<List<ReferentialMappingInformation>> currentMappingInfoForMemberNaming = new Box<>();
MappedRange activeMappedRange = null;
- Range previousMappedRange = null;
do {
Range originalRange = null;
// Try to parse any information added in comments above member namings
if (isCommentLineWithJsonBrace()) {
- final MemberNaming currentMember = activeMemberNaming;
+ final String currentRenamedNameFinal = previousRenamedName;
final MappedRange currentRange = activeMappedRange;
// Reading global info should cause member mapping to return since we are now reading
// headers pertaining to what could be a concatinated file.
@@ -349,38 +359,44 @@
parseMappingInformation(
info -> {
readGlobalInfo.set(info.isGlobalMappingInformation());
- // TODO(b/242673239): Support additional information for fields.
- if (currentMember == null) {
+ if (currentRenamedNameFinal == null) {
classNamingBuilder.addMappingInformation(
info,
conflictingInfo ->
diagnosticsHandler.warning(
MappingInformationDiagnostics.notAllowedCombination(
info, conflictingInfo, lineNo)));
- } else if (currentRange != null) {
+ return;
+ }
+ // Always add information to the current range, this will ensure that additional
+ // information is always placed the same place.
+ if (currentRange != null) {
currentRange.addMappingInformation(
info,
conflictingInfo ->
diagnosticsHandler.warning(
MappingInformationDiagnostics.notAllowedCombination(
info, conflictingInfo, lineNo)));
- if (info.isResidualMethodSignatureMappingInformation()) {
- ResidualMethodSignatureMappingInformation residualSignatureInfo =
- info.asResidualMethodSignatureMappingInformation();
- MethodSignature residualSignature =
- new MethodSignature(
- currentMember.getRenamedName(),
- DescriptorUtils.descriptorToJavaType(
- residualSignatureInfo.getReturnType()),
- ArrayUtils.mapToStringArray(
- residualSignatureInfo.getParameters(),
- DescriptorUtils::descriptorToJavaType));
- residualSignature =
- signatureCache
- .computeIfAbsent(residualSignature, Function.identity())
- .asMethodSignature();
- currentMember.setResidualSignatureInternal(residualSignature);
- currentRange.setResidualSignatureInternal(residualSignature);
+ }
+ if (info.isReferentialMappingInformation()) {
+ ReferentialMappingInformation referentialMappingInformation =
+ info.asReferentialMappingInformation();
+ MappingInformation.addMappingInformation(
+ currentMappingInfoForMemberNaming.computeIfAbsent(ArrayList::new),
+ referentialMappingInformation,
+ conflictingInfo ->
+ diagnosticsHandler.warning(
+ MappingInformationDiagnostics.notAllowedCombination(
+ info, conflictingInfo, lineNo)));
+ if (info.isResidualSignatureMappingInformation()) {
+ Signature residualSignature =
+ getResidualSignatureFromMappingInformation(
+ info.asResidualSignatureMappingInformation(), currentRenamedNameFinal);
+ currentResidualSignature.set(residualSignature);
+ if (currentRange != null) {
+ currentRange.setResidualSignatureInternal(
+ residualSignature.asMethodSignature());
+ }
}
}
});
@@ -431,7 +447,7 @@
if (activeMappedRange != null
&& activeMappedRange.signature == signature
&& activeMappedRange.renamedName.equals(renamedName)) {
- residualSignature = activeMappedRange.getResidualSignatureInternal();
+ residualSignature = activeMappedRange.getResidualSignature();
}
activeMappedRange =
classNamingBuilder.addMappedRange(
@@ -442,51 +458,114 @@
}
assert mappedRange == null || signature.isMethodSignature();
-
- // If this line refers to a member that should be added to classNamingBuilder (as opposed to
- // an inner inlined callee) and it's different from the the previous activeMemberNaming, then
- // flush (add) the current activeMemberNaming.
- if (activeMemberNaming != null) {
- boolean changedName = !activeMemberNaming.getRenamedName().equals(renamedName);
- boolean changedMappedRange = !Objects.equals(previousMappedRange, mappedRange);
+ if (previousOriginalSignature != null) {
+ boolean changedName = !previousRenamedName.equals(renamedName);
+ boolean changedMappedRange =
+ previousRange == null || !Objects.equals(previousRange, mappedRange);
boolean originalRangeChange = originalRange == null || !originalRange.isCardinal;
- if (changedName
- || previousMappedRange == null
- || changedMappedRange
- || originalRangeChange) {
- if (lastAddedNaming == null
- || !lastAddedNaming
- .getOriginalSignature()
- .equals(activeMemberNaming.getOriginalSignature())) {
- classNamingBuilder.addMemberEntry(
- activeMemberNaming, getResidualSignatureForMemberNaming(activeMemberNaming));
- lastAddedNaming = activeMemberNaming;
- }
+ if (changedName || changedMappedRange || originalRangeChange) {
+ lastAddedNaming =
+ addMemberEntryOrCopyInformation(
+ lastAddedNaming,
+ previousOriginalSignature,
+ previousRenamedName,
+ previousLineNumber,
+ currentResidualSignature,
+ currentMappingInfoForMemberNaming,
+ previousRange,
+ classNamingBuilder);
}
}
- activeMemberNaming = new MemberNaming(signature, renamedName, getPosition());
- previousMappedRange = mappedRange;
+ previousOriginalSignature = signature;
+ previousRenamedName = renamedName;
+ previousLineNumber = lineNo;
+ previousRange = mappedRange;
} while (nextLine(mapBuilder));
- if (activeMemberNaming != null) {
- boolean notAdded =
- lastAddedNaming == null
- || !lastAddedNaming
- .getOriginalSignature()
- .equals(activeMemberNaming.getOriginalSignature());
- if (previousMappedRange == null || notAdded) {
- classNamingBuilder.addMemberEntry(
- activeMemberNaming, getResidualSignatureForMemberNaming(activeMemberNaming));
- }
+ if (previousOriginalSignature != null) {
+ addMemberEntryOrCopyInformation(
+ lastAddedNaming,
+ previousOriginalSignature,
+ previousRenamedName,
+ previousLineNumber,
+ currentResidualSignature,
+ currentMappingInfoForMemberNaming,
+ previousRange,
+ classNamingBuilder);
}
}
- private Signature getResidualSignatureForMemberNaming(MemberNaming memberNaming) {
- if (memberNaming.hasResidualSignature()) {
- return memberNaming.getResidualSignatureInternal();
+ private MemberNaming addMemberEntryOrCopyInformation(
+ MemberNaming lastAddedNaming,
+ Signature originalSignature,
+ String renamedName,
+ int lineNumber,
+ Box<Signature> residualSignature,
+ Box<List<ReferentialMappingInformation>> additionalMappingInformation,
+ Range previousMappedRange,
+ ClassNaming.Builder classNamingBuilder) {
+ // If this line refers to a member that should be added to classNamingBuilder (as opposed to
+ // an inner inlined callee) and it's different from the the previous activeMemberNaming, then
+ // flush (add) the current activeMemberNaming.
+ if (previousMappedRange == null
+ || lastAddedNaming == null
+ || !lastAddedNaming.getRenamedName().equals(renamedName)
+ || !lastAddedNaming.getOriginalSignature().equals(originalSignature)) {
+ MemberNaming newMemberNaming =
+ new MemberNaming(
+ originalSignature,
+ getResidualSignatureForMemberNaming(
+ residualSignature, originalSignature, renamedName),
+ new LinePosition(lineNumber));
+ if (additionalMappingInformation.isSet()) {
+ newMemberNaming.addAllMappingInformationInternal(additionalMappingInformation.get());
+ }
+ classNamingBuilder.addMemberEntry(newMemberNaming);
+ residualSignature.clear();
+ additionalMappingInformation.clear();
+ return newMemberNaming;
}
- Signature signature =
- memberNaming.getOriginalSignature().asRenamed(memberNaming.getRenamedName());
+ if (additionalMappingInformation.isSet()) {
+ lastAddedNaming.addAllMappingInformationInternal(additionalMappingInformation.get());
+ additionalMappingInformation.clear();
+ }
+ residualSignature.clear();
+ return lastAddedNaming;
+ }
+
+ private Signature getResidualSignatureFromMappingInformation(
+ ResidualSignatureMappingInformation mappingInformation, String renamedName) {
+ if (mappingInformation.isResidualMethodSignatureMappingInformation()) {
+ ResidualMethodSignatureMappingInformation residualSignatureInfo =
+ mappingInformation.asResidualMethodSignatureMappingInformation();
+ MethodSignature residualSignature =
+ new MethodSignature(
+ renamedName,
+ DescriptorUtils.descriptorToJavaType(residualSignatureInfo.getReturnType()),
+ ArrayUtils.mapToStringArray(
+ residualSignatureInfo.getParameters(), DescriptorUtils::descriptorToJavaType));
+ return signatureCache
+ .computeIfAbsent(residualSignature, Function.identity())
+ .asMethodSignature();
+ } else {
+ assert mappingInformation.isResidualFieldSignatureMappingInformation();
+ ResidualFieldSignatureMappingInformation residualSignatureInfo =
+ mappingInformation.asResidualFieldSignatureMappingInformation();
+ FieldSignature residualSignature =
+ new FieldSignature(
+ renamedName, DescriptorUtils.descriptorToJavaType(residualSignatureInfo.getType()));
+ return signatureCache
+ .computeIfAbsent(residualSignature, Function.identity())
+ .asFieldSignature();
+ }
+ }
+
+ private Signature getResidualSignatureForMemberNaming(
+ Box<Signature> residualSignature, Signature originalSignature, String renamedName) {
+ if (residualSignature.isSet()) {
+ return residualSignature.get();
+ }
+ Signature signature = originalSignature.asRenamed(renamedName);
signature = signatureCache.computeIfAbsent(signature, Function.identity());
return signature;
}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
index b1d1eff..8ddef2b 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/CompilerSynthesizedMappingInformation.java
@@ -6,11 +6,12 @@
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import java.util.function.Consumer;
-public class CompilerSynthesizedMappingInformation extends MappingInformation {
+public class CompilerSynthesizedMappingInformation extends ReferentialMappingInformation {
public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_1_0;
public static final String ID = "com.android.tools.r8.synthesized";
@@ -55,7 +56,7 @@
@Override
public boolean allowOther(MappingInformation information) {
- return !information.isCompilerSynthesizedMappingInformation();
+ return true;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
index 828b5d8..7535bd3 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
@@ -7,12 +7,13 @@
import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import java.util.function.Consumer;
-public class FileNameInformation extends MappingInformation {
+public class FileNameInformation extends ReferentialMappingInformation {
private final String fileName;
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
index c62d4e6..6680142 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.naming.mappinginformation.ResidualSignatureMappingInformation.ResidualMethodSignatureMappingInformation;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
+import java.util.List;
import java.util.function.Consumer;
public abstract class MappingInformation {
@@ -89,6 +90,10 @@
return null;
}
+ public ResidualSignatureMappingInformation asResidualSignatureMappingInformation() {
+ return null;
+ }
+
public ResidualMethodSignatureMappingInformation asResidualMethodSignatureMappingInformation() {
return null;
}
@@ -177,6 +182,39 @@
}
}
+ public boolean isPositionalMappingInformation() {
+ return false;
+ }
+
+ public boolean isReferentialMappingInformation() {
+ return false;
+ }
+
+ public ReferentialMappingInformation asReferentialMappingInformation() {
+ return null;
+ }
+
+ public abstract static class ReferentialMappingInformation extends MappingInformation {
+
+ @Override
+ public boolean isReferentialMappingInformation() {
+ return true;
+ }
+
+ @Override
+ public ReferentialMappingInformation asReferentialMappingInformation() {
+ return this;
+ }
+ }
+
+ public abstract static class PositionalMappingInformation extends MappingInformation {
+
+ @Override
+ public boolean isPositionalMappingInformation() {
+ return true;
+ }
+ }
+
static JsonElement getJsonElementFromObject(
JsonObject object,
DiagnosticsHandler diagnosticsHandler,
@@ -190,4 +228,15 @@
}
return element;
}
+
+ public static <T extends MappingInformation> void addMappingInformation(
+ List<T> existingInfos, T newInfo, Consumer<MappingInformation> onProhibitedAddition) {
+ for (MappingInformation existing : existingInfos) {
+ if (!existing.allowOther(newInfo)) {
+ onProhibitedAddition.accept(existing);
+ return;
+ }
+ }
+ existingInfos.add(newInfo);
+ }
}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
index b38d707..238a9dd 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineCallsiteMappingInformation.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.utils.MethodReferenceUtils;
import com.google.gson.JsonElement;
@@ -16,7 +17,7 @@
import it.unimi.dsi.fastutil.ints.Int2IntSortedMap;
import java.util.function.Consumer;
-public class OutlineCallsiteMappingInformation extends MappingInformation {
+public class OutlineCallsiteMappingInformation extends PositionalMappingInformation {
public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
public static final MapVersion SUPPORTED_WITH_OUTLINE_VERSION = MapVersion.MAP_VERSION_2_1;
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
index 09c60d9..72b3b8f 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/OutlineMappingInformation.java
@@ -6,11 +6,12 @@
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import java.util.function.Consumer;
-public class OutlineMappingInformation extends MappingInformation {
+public class OutlineMappingInformation extends ReferentialMappingInformation {
public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
public static final String ID = "com.android.tools.r8.outline";
@@ -40,7 +41,7 @@
@Override
public boolean allowOther(MappingInformation information) {
- return !information.isOutlineMappingInformation();
+ return true;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
index 1c94da9..79c4023 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/ResidualSignatureMappingInformation.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.ReferentialMappingInformation;
import com.android.tools.r8.utils.ArrayUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -20,7 +21,7 @@
import java.util.Arrays;
import java.util.function.Consumer;
-public abstract class ResidualSignatureMappingInformation extends MappingInformation {
+public abstract class ResidualSignatureMappingInformation extends ReferentialMappingInformation {
public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_EXPERIMENTAL;
public static final String ID = "com.android.tools.r8.residualsignature";
@@ -41,11 +42,6 @@
protected abstract String serializeInternal();
- @Override
- public boolean allowOther(MappingInformation information) {
- return !information.isResidualSignatureMappingInformation();
- }
-
public static boolean isSupported(MapVersion version) {
return version.isGreaterThanOrEqualTo(SUPPORTED_VERSION);
}
@@ -67,6 +63,16 @@
}
}
+ @Override
+ public boolean isResidualSignatureMappingInformation() {
+ return true;
+ }
+
+ @Override
+ public ResidualSignatureMappingInformation asResidualSignatureMappingInformation() {
+ return this;
+ }
+
public static class ResidualMethodSignatureMappingInformation
extends ResidualSignatureMappingInformation {
@@ -122,6 +128,16 @@
assert existing.isResidualMethodSignatureMappingInformation();
return this;
}
+
+ @Override
+ public boolean allowOther(MappingInformation information) {
+ if (!information.isResidualMethodSignatureMappingInformation()) {
+ return true;
+ }
+ ResidualMethodSignatureMappingInformation other =
+ information.asResidualMethodSignatureMappingInformation();
+ return returnType.equals(other.returnType) && Arrays.equals(parameters, other.parameters);
+ }
}
public static class ResidualFieldSignatureMappingInformation
@@ -138,6 +154,10 @@
return new ResidualFieldSignatureMappingInformation(field.getType().toDescriptorString());
}
+ public String getType() {
+ return type;
+ }
+
@Override
protected String serializeInternal() {
return type;
@@ -163,5 +183,11 @@
assert existing.isResidualFieldSignatureMappingInformation();
return this;
}
+
+ @Override
+ public boolean allowOther(MappingInformation information) {
+ return !information.isResidualFieldSignatureMappingInformation()
+ || type.equals(information.asResidualFieldSignatureMappingInformation().getType());
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
index da0c1f3..589a743 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/RewriteFrameMappingInformation.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.naming.MapVersion;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.retrace.internal.RetraceStackTraceContextImpl;
@@ -25,7 +26,7 @@
import java.util.List;
import java.util.function.Consumer;
-public class RewriteFrameMappingInformation extends MappingInformation {
+public class RewriteFrameMappingInformation extends PositionalMappingInformation {
public static final MapVersion SUPPORTED_VERSION = MapVersion.MAP_VERSION_2_0;
public static final String ID = "com.android.tools.r8.rewriteFrame";
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
index 3348063..98699b2 100644
--- a/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/UnknownJsonMappingInformation.java
@@ -6,10 +6,11 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.naming.MappingComposeException;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation.PositionalMappingInformation;
import com.google.gson.JsonObject;
import java.util.function.Consumer;
-public class UnknownJsonMappingInformation extends MappingInformation {
+public class UnknownJsonMappingInformation extends PositionalMappingInformation {
private final String id;
private final String payload;
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java b/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java
new file mode 100644
index 0000000..26d5a16
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/internal/MemberNamingWithMappedRangesOfName.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.internal;
+
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
+import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.utils.ListUtils;
+import java.util.List;
+
+class MemberNamingWithMappedRangesOfName {
+
+ private final MappedRangesOfName mappedRangesOfName;
+ private final MemberNaming methodMemberNaming;
+
+ MemberNamingWithMappedRangesOfName(
+ MemberNaming methodMemberNaming, MappedRangesOfName mappedRangesOfName) {
+ this.methodMemberNaming = methodMemberNaming;
+ this.mappedRangesOfName = mappedRangesOfName;
+ }
+
+ List<MappedRange> allRangesForLine(int line) {
+ return mappedRangesOfName.allRangesForLine(line, false);
+ }
+
+ List<MappedRange> mappedRangesWithNoMinifiedRange() {
+ return ListUtils.filter(
+ mappedRangesOfName.getMappedRanges(), mappedRange -> mappedRange.minifiedRange == null);
+ }
+
+ List<MappedRange> getMappedRanges() {
+ return mappedRangesOfName.getMappedRanges();
+ }
+
+ public MemberNaming getMemberNaming() {
+ return methodMemberNaming;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
index 1b2be6a..45ad91a 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceClassResultImpl.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.MemberNaming.FieldSignature;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.naming.MemberNaming.Signature;
import com.android.tools.r8.naming.mappinginformation.MappingInformation;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.FieldReference;
@@ -23,8 +22,8 @@
import com.android.tools.r8.retrace.RetraceStackTraceContext;
import com.android.tools.r8.retrace.RetraceUnknownJsonMappingInformationResult;
import com.android.tools.r8.retrace.RetracedSourceFile;
+import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Pair;
-import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
@@ -63,6 +62,32 @@
return lookupField(FieldDefinition.create(fieldReference));
}
+ private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
+ return lookup(
+ fieldDefinition,
+ RetraceClassResultImpl::lookupMemberNamingsForFieldDefinition,
+ RetraceFieldResultImpl::new);
+ }
+
+ private static List<MemberNaming> lookupMemberNamingsForFieldDefinition(
+ ClassNamingForNameMapper mapper, FieldDefinition fieldDefinition) {
+ List<MemberNaming> memberNamings =
+ mapper.mappedFieldNamingsByName.get(fieldDefinition.getName());
+ if (memberNamings == null || memberNamings.isEmpty()) {
+ return null;
+ }
+ if (fieldDefinition.isFullFieldDefinition()) {
+ FieldSignature fieldSignature =
+ FieldSignature.fromFieldReference(
+ fieldDefinition.asFullFieldDefinition().getFieldReference());
+ memberNamings =
+ ListUtils.filter(
+ memberNamings,
+ memberNaming -> memberNaming.getResidualSignature().equals(fieldSignature));
+ }
+ return memberNamings;
+ }
+
@Override
public RetraceMethodResultImpl lookupMethod(String methodName) {
return lookupMethod(MethodDefinition.create(obfuscatedReference, methodName));
@@ -79,82 +104,64 @@
return lookupMethod(MethodDefinition.create(reference));
}
- private static MethodSignature getSignature(
- ClassNamingForNameMapper mapper, MethodDefinition definition) {
- if (mapper != null && definition.isFullMethodDefinition()) {
- MemberNaming lookup =
- mapper.lookup(
- MethodSignature.fromMethodReference(
- definition.asFullMethodDefinition().getMethodReference()));
- if (lookup != null) {
- return lookup.getOriginalSignature().asMethodSignature();
- }
- }
- return null;
- }
-
- private static FieldSignature getSignature(
- ClassNamingForNameMapper mapper, FieldDefinition definition) {
- if (mapper != null && definition.isFullFieldDefinition()) {
- MemberNaming lookup =
- mapper.lookup(
- FieldSignature.fromFieldReference(
- definition.asFullFieldDefinition().getFieldReference()));
- if (lookup != null) {
- return lookup.getOriginalSignature().asFieldSignature();
- }
- }
- return null;
- }
-
- private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
- return lookup(
- fieldDefinition,
- getSignature(mapper, fieldDefinition),
- (mapper, name) -> {
- List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
- if (memberNamings == null || memberNamings.isEmpty()) {
- return null;
- }
- return memberNamings;
- },
- RetraceFieldResultImpl::new);
- }
-
private RetraceMethodResultImpl lookupMethod(MethodDefinition methodDefinition) {
return lookup(
methodDefinition,
- getSignature(mapper, methodDefinition),
- (mapper, name) -> {
- MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
- if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
- return null;
- }
- return mappedRanges.getMappedRanges();
- },
+ RetraceClassResultImpl::lookupMappedRangesForMethodDefinition,
RetraceMethodResultImpl::new);
}
- private <T, R, D extends Definition, S extends Signature> R lookup(
+ private static List<MemberNamingWithMappedRangesOfName> lookupMappedRangesForMethodDefinition(
+ ClassNamingForNameMapper mapper, MethodDefinition methodDefinition) {
+ MappedRangesOfName mappedRanges =
+ mapper.mappedRangesByRenamedName.get(methodDefinition.getName());
+ if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
+ return null;
+ }
+ List<MappedRangesOfName> partitions = mappedRanges.partitionOnMethodSignature();
+ if (methodDefinition.isFullMethodDefinition()) {
+ MethodSignature methodSignature =
+ MethodSignature.fromMethodReference(
+ methodDefinition.asFullMethodDefinition().getMethodReference());
+ partitions =
+ ListUtils.filter(
+ partitions,
+ partition ->
+ ListUtils.last(partition.getMappedRanges())
+ .getResidualSignature()
+ .equals(methodSignature));
+ }
+ boolean isAmbiguous = partitions.size() > 1;
+ return ListUtils.map(
+ partitions,
+ mappedRangesOfName ->
+ new MemberNamingWithMappedRangesOfName(
+ mappedRangesOfName.getMemberNaming(mapper, isAmbiguous), mappedRangesOfName));
+ }
+
+ private static <T, D extends Definition> void lookupElement(
+ RetraceClassElementImpl element,
D definition,
- S originalSignature,
- BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
- ResultConstructor<T, R, D, S> constructor) {
+ List<Pair<RetraceClassElementImpl, T>> mappings,
+ BiFunction<ClassNamingForNameMapper, D, T> lookupFunction) {
+ if (element.mapper != null) {
+ T mappedElements = lookupFunction.apply(element.mapper, definition);
+ if (mappedElements != null) {
+ mappings.add(new Pair<>(element, mappedElements));
+ return;
+ }
+ }
+ mappings.add(new Pair<>(element, null));
+ }
+
+ private <T, R, D extends Definition> R lookup(
+ D definition,
+ BiFunction<ClassNamingForNameMapper, D, T> lookupFunction,
+ ResultConstructor<T, R, D> constructor) {
List<Pair<RetraceClassElementImpl, T>> mappings = new ArrayList<>();
internalStream()
- .forEach(
- element -> {
- if (mapper != null) {
- assert element.mapper != null;
- T mappedElements = lookupFunction.apply(element.mapper, definition.getName());
- if (mappedElements != null) {
- mappings.add(new Pair<>(element, mappedElements));
- return;
- }
- }
- mappings.add(new Pair<>(element, null));
- });
- return constructor.create(this, mappings, definition, originalSignature, retracer);
+ .forEach(element -> lookupElement(element, definition, mappings, lookupFunction));
+ return constructor.create(this, mappings, definition, retracer);
}
@Override
@@ -212,12 +219,11 @@
mapper);
}
- private interface ResultConstructor<T, R, D, S> {
+ private interface ResultConstructor<T, R, D> {
R create(
RetraceClassResultImpl classResult,
List<Pair<RetraceClassElementImpl, T>> mappings,
D definition,
- S originalSignature,
RetracerImpl retracer);
}
@@ -271,14 +277,7 @@
private RetraceFieldResultImpl lookupField(FieldDefinition fieldDefinition) {
return lookup(
fieldDefinition,
- getSignature(mapper, fieldDefinition),
- (mapper, name) -> {
- List<MemberNaming> memberNamings = mapper.mappedFieldNamingsByName.get(name);
- if (memberNamings == null || memberNamings.isEmpty()) {
- return null;
- }
- return memberNamings;
- },
+ RetraceClassResultImpl::lookupMemberNamingsForFieldDefinition,
RetraceFieldResultImpl::new);
}
@@ -290,34 +289,17 @@
private RetraceMethodResultImpl lookupMethod(MethodDefinition methodDefinition) {
return lookup(
methodDefinition,
- getSignature(mapper, methodDefinition),
- (mapper, name) -> {
- MappedRangesOfName mappedRanges = mapper.mappedRangesByRenamedName.get(name);
- if (mappedRanges == null || mappedRanges.getMappedRanges().isEmpty()) {
- return null;
- }
- return mappedRanges.getMappedRanges();
- },
+ RetraceClassResultImpl::lookupMappedRangesForMethodDefinition,
RetraceMethodResultImpl::new);
}
- private <T, R, D extends Definition, S extends Signature> R lookup(
+ private <T, R, D extends Definition> R lookup(
D definition,
- S originalSignature,
- BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
- ResultConstructor<T, R, D, S> constructor) {
- List<Pair<RetraceClassElementImpl, T>> mappings = ImmutableList.of();
- if (mapper != null) {
- T result = lookupFunction.apply(mapper, definition.getName());
- if (result != null) {
- mappings = ImmutableList.of(new Pair<>(this, result));
- }
- }
- if (mappings.isEmpty()) {
- mappings = ImmutableList.of(new Pair<>(this, null));
- }
- return constructor.create(
- classResult, mappings, definition, originalSignature, classResult.retracer);
+ BiFunction<ClassNamingForNameMapper, D, T> lookupFunction,
+ ResultConstructor<T, R, D> constructor) {
+ List<Pair<RetraceClassElementImpl, T>> mappings = new ArrayList<>();
+ RetraceClassResultImpl.lookupElement(this, definition, mappings, lookupFunction);
+ return constructor.create(classResult, mappings, definition, classResult.retracer);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
index d1d7203..afade35 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFieldResultImpl.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.retrace.internal;
-import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.MemberNaming.FieldSignature;
import com.android.tools.r8.references.Reference;
@@ -23,19 +22,16 @@
private final RetraceClassResultImpl classResult;
private final List<Pair<RetraceClassElementImpl, List<MemberNaming>>> memberNamings;
private final FieldDefinition fieldDefinition;
- private final FieldSignature originalFieldSignature;
private final Retracer retracer;
RetraceFieldResultImpl(
RetraceClassResultImpl classResult,
List<Pair<RetraceClassElementImpl, List<MemberNaming>>> memberNamings,
FieldDefinition fieldDefinition,
- FieldSignature originalFieldSignature,
Retracer retracer) {
this.classResult = classResult;
this.memberNamings = memberNamings;
this.fieldDefinition = fieldDefinition;
- this.originalFieldSignature = originalFieldSignature;
this.retracer = retracer;
assert classResult != null;
assert !memberNamings.isEmpty();
@@ -55,7 +51,8 @@
classElement,
RetracedFieldReferenceImpl.create(
fieldDefinition.substituteHolder(
- classElement.getRetracedClass().getClassReference()))));
+ classElement.getRetracedClass().getClassReference())),
+ null));
}
return memberNamings.stream()
.map(
@@ -78,7 +75,8 @@
fieldSignature.isQualified()
? fieldSignature.toUnqualifiedName()
: fieldSignature.name,
- Reference.typeFromTypeName(fieldSignature.type))));
+ Reference.typeFromTypeName(fieldSignature.type))),
+ memberNaming);
});
});
}
@@ -105,23 +103,27 @@
private final RetracedFieldReferenceImpl fieldReference;
private final RetraceFieldResultImpl retraceFieldResult;
private final RetraceClassElementImpl classElement;
+ private final MemberNaming memberNaming;
private ElementImpl(
RetraceFieldResultImpl retraceFieldResult,
RetraceClassElementImpl classElement,
- RetracedFieldReferenceImpl fieldReference) {
+ RetracedFieldReferenceImpl fieldReference,
+ MemberNaming memberNaming) {
this.classElement = classElement;
this.fieldReference = fieldReference;
this.retraceFieldResult = retraceFieldResult;
+ this.memberNaming = memberNaming;
}
@Override
public boolean isCompilerSynthesized() {
- throw new Unimplemented("b/172014416");
+ return memberNaming != null && memberNaming.isCompilerSynthesized();
}
@Override
public boolean isUnknown() {
+ assert (memberNaming == null) == fieldReference.isUnknown();
return fieldReference.isUnknown();
}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
index 9d22b04..cfaa06e 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceFrameResultImpl.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
+import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.Range;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.retrace.RetraceFrameElement;
@@ -36,7 +37,8 @@
private final RetraceClassResultImpl classResult;
private final MethodDefinition methodDefinition;
private final OptionalInt obfuscatedPosition;
- private final List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges;
+ private final List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>>
+ mappedRanges;
private final RetracerImpl retracer;
private final RetraceStackTraceContextImpl context;
@@ -44,7 +46,7 @@
public RetraceFrameResultImpl(
RetraceClassResultImpl classResult,
- List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges,
+ List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> mappedRanges,
MethodDefinition methodDefinition,
OptionalInt obfuscatedPosition,
RetracerImpl retracer,
@@ -55,35 +57,46 @@
this.mappedRanges = mappedRanges;
this.retracer = retracer;
this.context = context;
+ assert !mappedRanges.isEmpty();
}
@Override
public boolean isAmbiguous() {
if (isAmbiguousCache.isUnknown()) {
- if (mappedRanges.size() > 1) {
- isAmbiguousCache = OptionalBool.TRUE;
- return true;
- }
- List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
- if (methodRanges != null && !methodRanges.isEmpty()) {
- MappedRange initialRange = methodRanges.get(0);
- for (MappedRange mappedRange : methodRanges) {
- if (isMappedRangeAmbiguous(mappedRange)) {
- isAmbiguousCache = OptionalBool.TRUE;
- return true;
- }
- if (mappedRange != initialRange
- && (mappedRange.minifiedRange == null
- || !mappedRange.minifiedRange.equals(initialRange.minifiedRange))) {
- isAmbiguousCache = OptionalBool.TRUE;
- return true;
- }
+ isAmbiguousCache = OptionalBool.of(computeIsAmbiguous());
+ assert !isAmbiguousCache.isUnknown();
+ }
+ return isAmbiguousCache.isTrue();
+ }
+
+ private boolean computeIsAmbiguous() {
+ if (mappedRanges.size() > 1) {
+ return true;
+ }
+ List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges =
+ mappedRanges.get(0).getSecond();
+ if (memberNamingWithMappedRanges == null) {
+ return false;
+ }
+ if (memberNamingWithMappedRanges.size() > 1) {
+ return true;
+ }
+ assert !memberNamingWithMappedRanges.isEmpty();
+ List<MappedRange> methodRanges = memberNamingWithMappedRanges.get(0).getMappedRanges();
+ if (methodRanges != null && !methodRanges.isEmpty()) {
+ MappedRange initialRange = methodRanges.get(0);
+ for (MappedRange mappedRange : methodRanges) {
+ if (isMappedRangeAmbiguous(mappedRange)) {
+ return true;
+ }
+ if (mappedRange != initialRange
+ && (mappedRange.minifiedRange == null
+ || !mappedRange.minifiedRange.equals(initialRange.minifiedRange))) {
+ return true;
}
}
- isAmbiguousCache = OptionalBool.FALSE;
}
- assert !isAmbiguousCache.isUnknown();
- return isAmbiguousCache.isTrue();
+ return false;
}
private boolean isMappedRangeAmbiguous(MappedRange mappedRange) {
@@ -102,8 +115,10 @@
.flatMap(
mappedRangePair -> {
RetraceClassElementImpl classElement = mappedRangePair.getFirst();
- List<MappedRange> mappedRanges = mappedRangePair.getSecond();
- if (mappedRanges == null || mappedRanges.isEmpty()) {
+ List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRangesOfNames =
+ mappedRangePair.getSecond();
+ if (memberNamingWithMappedRangesOfNames == null
+ || memberNamingWithMappedRangesOfNames.isEmpty()) {
return Stream.of(
new ElementImpl(
this,
@@ -112,32 +127,46 @@
methodDefinition.substituteHolder(
classElement.getRetracedClass().getClassReference())),
ImmutableList.of(),
+ null,
obfuscatedPosition,
retracer));
}
// Iterate over mapped ranges that may have different positions than specified.
List<ElementImpl> ambiguousFrames = new ArrayList<>();
- Range minifiedRange = mappedRanges.get(0).minifiedRange;
- List<MappedRange> mappedRangesForElement = Lists.newArrayList(mappedRanges.get(0));
- for (int i = 1; i < mappedRanges.size(); i++) {
- MappedRange mappedRange = mappedRanges.get(i);
- if (minifiedRange == null || !minifiedRange.equals(mappedRange.minifiedRange)) {
- // This is a new frame
- separateAmbiguousOriginalPositions(
- classElement, mappedRangesForElement, ambiguousFrames);
- mappedRangesForElement = new ArrayList<>();
- minifiedRange = mappedRange.minifiedRange;
+ for (MemberNamingWithMappedRangesOfName memberNamingWithMappedRangesOfName :
+ memberNamingWithMappedRangesOfNames) {
+ List<MappedRange> mappedRangesForMemberNaming =
+ memberNamingWithMappedRangesOfName.getMappedRanges();
+ MappedRange firstMappedRange = mappedRangesForMemberNaming.get(0);
+ Range minifiedRange = firstMappedRange.minifiedRange;
+ List<MappedRange> mappedRangesForElement = Lists.newArrayList(firstMappedRange);
+ for (int i = 1; i < mappedRangesForMemberNaming.size(); i++) {
+ MappedRange mappedRange = mappedRangesForMemberNaming.get(i);
+ if (minifiedRange == null || !minifiedRange.equals(mappedRange.minifiedRange)) {
+ // This is a new frame
+ separateAmbiguousOriginalPositions(
+ classElement,
+ memberNamingWithMappedRangesOfName.getMemberNaming(),
+ mappedRangesForElement,
+ ambiguousFrames);
+ mappedRangesForElement = new ArrayList<>();
+ minifiedRange = mappedRange.minifiedRange;
+ }
+ mappedRangesForElement.add(mappedRange);
}
- mappedRangesForElement.add(mappedRange);
+ separateAmbiguousOriginalPositions(
+ classElement,
+ memberNamingWithMappedRangesOfName.getMemberNaming(),
+ mappedRangesForElement,
+ ambiguousFrames);
}
- separateAmbiguousOriginalPositions(
- classElement, mappedRangesForElement, ambiguousFrames);
return ambiguousFrames.stream();
});
}
private void separateAmbiguousOriginalPositions(
RetraceClassElementImpl classElement,
+ MemberNaming memberNaming,
List<MappedRange> frames,
List<ElementImpl> allAmbiguousElements) {
// We have a single list of frames where minified positional information may produce ambiguous
@@ -145,7 +174,7 @@
if (!isAmbiguous() || !isMappedRangeAmbiguous(frames.get(0))) {
allAmbiguousElements.add(
elementFromMappedRanges(
- ListUtils.map(frames, MappedRangeForFrame::create), classElement));
+ memberNaming, ListUtils.map(frames, MappedRangeForFrame::create), classElement));
return;
}
assert frames.size() > 0;
@@ -165,19 +194,19 @@
}
} else {
newFrames.forEach(
- ambiguousFrames -> {
- ambiguousFrames.add(MappedRangeForFrame.create(frame));
- });
+ ambiguousFrames -> ambiguousFrames.add(MappedRangeForFrame.create(frame)));
}
});
newFrames.forEach(
- ambiguousFrames -> {
- allAmbiguousElements.add(elementFromMappedRanges(ambiguousFrames, classElement));
- });
+ ambiguousFrames ->
+ allAmbiguousElements.add(
+ elementFromMappedRanges(memberNaming, ambiguousFrames, classElement)));
}
private ElementImpl elementFromMappedRanges(
- List<MappedRangeForFrame> mappedRangesForElement, RetraceClassElementImpl classElement) {
+ MemberNaming memberNaming,
+ List<MappedRangeForFrame> mappedRangesForElement,
+ RetraceClassElementImpl classElement) {
MappedRangeForFrame topFrame = mappedRangesForElement.get(0);
MethodReference methodReference =
methodReferenceFromMappedRange(
@@ -187,6 +216,7 @@
classElement,
getRetracedMethod(methodReference, topFrame, obfuscatedPosition),
mappedRangesForElement,
+ memberNaming,
obfuscatedPosition,
retracer);
}
@@ -221,7 +251,8 @@
@Override
public boolean isEmpty() {
- return mappedRanges.isEmpty();
+ List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+ return mappedRangesOfNames == null || mappedRangesOfNames.isEmpty();
}
public static class ElementImpl implements RetraceFrameElement {
@@ -230,6 +261,7 @@
private final RetraceFrameResultImpl retraceFrameResult;
private final RetraceClassElementImpl classElement;
private final List<MappedRangeForFrame> mappedRanges;
+ private final MemberNaming memberNaming;
private final OptionalInt obfuscatedPosition;
private final RetracerImpl retracer;
@@ -238,12 +270,14 @@
RetraceClassElementImpl classElement,
RetracedMethodReferenceImpl methodReference,
List<MappedRangeForFrame> mappedRanges,
+ MemberNaming memberNaming,
OptionalInt obfuscatedPosition,
RetracerImpl retracer) {
this.methodReference = methodReference;
this.retraceFrameResult = retraceFrameResult;
this.classElement = classElement;
this.mappedRanges = mappedRanges;
+ this.memberNaming = memberNaming;
this.obfuscatedPosition = obfuscatedPosition;
this.retracer = retracer;
}
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java b/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
index 19b2c15..1a6ca9a 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/RetraceMethodResultImpl.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.retrace.internal;
-import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
+import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.naming.mappinginformation.OutlineCallsiteMappingInformation;
import com.android.tools.r8.references.MethodReference;
@@ -19,30 +19,26 @@
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Pair;
import java.util.ArrayList;
-import java.util.HashSet;
import java.util.List;
import java.util.OptionalInt;
-import java.util.Set;
import java.util.stream.Stream;
public class RetraceMethodResultImpl implements RetraceMethodResult {
private final MethodDefinition methodDefinition;
- private final MethodSignature originalMethodSignature;
private final RetraceClassResultImpl classResult;
- private final List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges;
+ private final List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>>
+ mappedRanges;
private final RetracerImpl retracer;
RetraceMethodResultImpl(
RetraceClassResultImpl classResult,
- List<Pair<RetraceClassElementImpl, List<MappedRange>>> mappedRanges,
+ List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> mappedRanges,
MethodDefinition methodDefinition,
- MethodSignature originalMethodSignature,
RetracerImpl retracer) {
this.classResult = classResult;
this.mappedRanges = mappedRanges;
this.methodDefinition = methodDefinition;
- this.originalMethodSignature = originalMethodSignature;
this.retracer = retracer;
assert classResult != null;
assert !mappedRanges.isEmpty();
@@ -53,73 +49,71 @@
if (mappedRanges.size() > 1) {
return true;
}
- if (originalMethodSignature != null) {
- return false;
- }
- List<MappedRange> methodRanges = mappedRanges.get(0).getSecond();
- if (methodRanges == null || methodRanges.isEmpty()) {
- return false;
- }
- MappedRange lastRange = methodRanges.get(0);
- for (MappedRange mappedRange : methodRanges) {
- if (mappedRange != lastRange
- && (mappedRange.minifiedRange == null
- || !mappedRange.minifiedRange.equals(lastRange.minifiedRange))) {
- return true;
- }
- }
- return false;
+ List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+ return mappedRangesOfNames != null && mappedRangesOfNames.size() > 1;
}
@Override
public boolean isEmpty() {
- return mappedRanges == null || mappedRanges.isEmpty();
+ List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond();
+ return mappedRangesOfNames == null || mappedRangesOfNames.isEmpty();
}
@Override
public RetraceFrameResultImpl narrowByPosition(
RetraceStackTraceContext context, OptionalInt position) {
- List<Pair<RetraceClassElementImpl, List<MappedRange>>> narrowedRanges = new ArrayList<>();
+ List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> narrowedRanges =
+ new ArrayList<>();
RetraceStackTraceContextImpl stackTraceContext = null;
if (context instanceof RetraceStackTraceContextImpl) {
stackTraceContext = (RetraceStackTraceContextImpl) context;
}
- for (Pair<RetraceClassElementImpl, List<MappedRange>> mappedRange : mappedRanges) {
- if (mappedRange.getSecond() == null) {
+ for (Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange :
+ mappedRanges) {
+ List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges =
+ mappedRange.getSecond();
+ if (memberNamingWithMappedRanges == null) {
narrowedRanges.add(new Pair<>(mappedRange.getFirst(), null));
continue;
}
- MappedRangesOfName mappedRangesOfElement = new MappedRangesOfName(mappedRange.getSecond());
- List<MappedRange> mappedRangesForPosition = null;
boolean hasPosition = position.isPresent() && position.getAsInt() >= 0;
- if (hasPosition) {
- mappedRangesForPosition =
- mappedRangesOfElement.allRangesForLine(position.getAsInt(), false);
- }
- if (mappedRangesForPosition == null || mappedRangesForPosition.isEmpty()) {
- mappedRangesForPosition =
- hasPosition
- ? ListUtils.filter(
- mappedRangesOfElement.getMappedRanges(), range -> range.minifiedRange == null)
- : mappedRangesOfElement.getMappedRanges();
- }
- if (mappedRangesForPosition != null && !mappedRangesForPosition.isEmpty()) {
- if (stackTraceContext != null && stackTraceContext.hasRewritePosition()) {
- List<OutlineCallsiteMappingInformation> outlineCallsiteInformation =
- ListUtils.last(mappedRangesForPosition).getOutlineCallsiteInformation();
- if (!outlineCallsiteInformation.isEmpty()) {
- assert outlineCallsiteInformation.size() == 1
- : "There can only be one outline entry for a line";
- return narrowByPosition(
- stackTraceContext.buildFromThis().clearRewritePosition().build(),
- OptionalInt.of(
- outlineCallsiteInformation
- .get(0)
- .rewritePosition(stackTraceContext.getRewritePosition())));
+ List<MemberNamingWithMappedRangesOfName> newMemberNamingsResult = new ArrayList<>();
+ for (MemberNamingWithMappedRangesOfName memberNamingWithMappedRange :
+ memberNamingWithMappedRanges) {
+ List<MappedRange> mappedRangesForPosition = null;
+ if (hasPosition) {
+ mappedRangesForPosition =
+ memberNamingWithMappedRange.allRangesForLine(position.getAsInt());
+ }
+ if (mappedRangesForPosition == null || mappedRangesForPosition.isEmpty()) {
+ mappedRangesForPosition =
+ hasPosition
+ ? memberNamingWithMappedRange.mappedRangesWithNoMinifiedRange()
+ : memberNamingWithMappedRange.getMappedRanges();
+ }
+ if (mappedRangesForPosition != null && !mappedRangesForPosition.isEmpty()) {
+ MemberNamingWithMappedRangesOfName newMemberNaming =
+ new MemberNamingWithMappedRangesOfName(
+ memberNamingWithMappedRange.getMemberNaming(),
+ new MappedRangesOfName(mappedRangesForPosition));
+ newMemberNamingsResult.add(newMemberNaming);
+ if (stackTraceContext != null && stackTraceContext.hasRewritePosition()) {
+ List<OutlineCallsiteMappingInformation> outlineCallsiteInformation =
+ ListUtils.last(mappedRangesForPosition).getOutlineCallsiteInformation();
+ if (!outlineCallsiteInformation.isEmpty()) {
+ assert outlineCallsiteInformation.size() == 1
+ : "There can only be one outline entry for a line";
+ return narrowByPosition(
+ stackTraceContext.buildFromThis().clearRewritePosition().build(),
+ OptionalInt.of(
+ outlineCallsiteInformation
+ .get(0)
+ .rewritePosition(stackTraceContext.getRewritePosition())));
+ }
}
}
- narrowedRanges.add(new Pair<>(mappedRange.getFirst(), mappedRangesForPosition));
}
+ narrowedRanges.add(new Pair<>(mappedRange.getFirst(), newMemberNamingsResult));
}
return new RetraceFrameResultImpl(
classResult,
@@ -132,48 +126,43 @@
@Override
public Stream<RetraceMethodElement> stream() {
- if (originalMethodSignature != null) {
- // Even if we know exactly the retraced residual definition, the class element
- // may still be ambiguous.
- return mappedRanges.stream()
- .map(
- mappedRangePair -> {
- RetraceClassElementImpl classElement = mappedRangePair.getFirst();
- MethodReference methodReference =
- RetraceUtils.methodReferenceFromMethodSignature(
- originalMethodSignature,
- classElement.getRetracedClass().getClassReference());
- return new ElementImpl(
- this, classElement, RetracedMethodReferenceImpl.create(methodReference));
- });
- }
return mappedRanges.stream()
.flatMap(
mappedRangePair -> {
RetraceClassElementImpl classElement = mappedRangePair.getFirst();
- List<MappedRange> mappedRanges = mappedRangePair.getSecond();
- if (mappedRanges == null || mappedRanges.isEmpty()) {
+ List<MemberNamingWithMappedRangesOfName> memberNamingsWithMappedRange =
+ mappedRangePair.getSecond();
+ if (memberNamingsWithMappedRange == null || memberNamingsWithMappedRange.isEmpty()) {
return Stream.of(
new ElementImpl(
this,
classElement,
RetracedMethodReferenceImpl.create(
methodDefinition.substituteHolder(
- classElement.getRetracedClass().getClassReference()))));
+ classElement.getRetracedClass().getClassReference())),
+ null));
}
- List<ElementImpl> results = new ArrayList<>();
- Set<MethodReference> seenMethodReferences = new HashSet<>();
- for (MappedRange mappedRange : mappedRanges) {
- MethodReference methodReference =
- RetraceUtils.methodReferenceFromMappedRange(
- mappedRange, classElement.getRetracedClass().getClassReference());
- if (seenMethodReferences.add(methodReference)) {
- results.add(
- new ElementImpl(
- this, classElement, RetracedMethodReferenceImpl.create(methodReference)));
- }
- }
- return results.stream();
+ return ListUtils.map(
+ memberNamingsWithMappedRange,
+ memberNamingWithMappedRangesOfName -> {
+ MemberNaming memberNaming =
+ memberNamingWithMappedRangesOfName.getMemberNaming();
+ MethodSignature originalSignature =
+ memberNaming != null
+ ? memberNaming.getOriginalSignature().asMethodSignature()
+ : ListUtils.last(memberNamingWithMappedRangesOfName.getMappedRanges())
+ .getOriginalSignature()
+ .asMethodSignature();
+ MethodReference methodReference =
+ RetraceUtils.methodReferenceFromMethodSignature(
+ originalSignature, classElement.getRetracedClass().getClassReference());
+ return new ElementImpl(
+ this,
+ classElement,
+ RetracedMethodReferenceImpl.create(methodReference),
+ memberNamingWithMappedRangesOfName);
+ })
+ .stream();
});
}
@@ -182,19 +171,28 @@
private final RetracedMethodReferenceImpl methodReference;
private final RetraceMethodResultImpl retraceMethodResult;
private final RetraceClassElementImpl classElement;
+ private final MemberNamingWithMappedRangesOfName mapping;
private ElementImpl(
RetraceMethodResultImpl retraceMethodResult,
RetraceClassElementImpl classElement,
- RetracedMethodReferenceImpl methodReference) {
+ RetracedMethodReferenceImpl methodReference,
+ MemberNamingWithMappedRangesOfName mapping) {
this.classElement = classElement;
this.retraceMethodResult = retraceMethodResult;
this.methodReference = methodReference;
+ this.mapping = mapping;
+ assert mapping != null;
}
@Override
public boolean isCompilerSynthesized() {
- throw new Unimplemented("b/172014416");
+ if (mapping.getMemberNaming() != null) {
+ return mapping.getMemberNaming().isCompilerSynthesized();
+ } else {
+ List<MappedRange> mappedRanges = mapping.getMappedRanges();
+ return !mappedRanges.isEmpty() && ListUtils.last(mappedRanges).isCompilerSynthesized();
+ }
}
@Override
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index fe4baac..7d23fa4 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -139,7 +139,7 @@
if (appView.options().ignoreMissingClasses) {
appView.reporter().warning(diagnostic);
} else {
- throw appView.reporter().fatalError(diagnostic);
+ appView.reporter().error(diagnostic);
}
}
return build();
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java b/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
index cd7460b..69c9714 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApiLevel.java
@@ -95,6 +95,8 @@
return AndroidApiLevel.O;
case V39:
return AndroidApiLevel.P;
+ case V40:
+ return AndroidApiLevel.ANDROID_PLATFORM;
default:
throw new Unreachable();
}
diff --git a/src/main/java/com/android/tools/r8/utils/DexVersion.java b/src/main/java/com/android/tools/r8/utils/DexVersion.java
index 492c87b..cdac93d 100644
--- a/src/main/java/com/android/tools/r8/utils/DexVersion.java
+++ b/src/main/java/com/android/tools/r8/utils/DexVersion.java
@@ -10,10 +10,11 @@
* Android dex version
*/
public enum DexVersion {
- V35(35, new byte[]{'0', '3', '5'}),
- V37(37, new byte[]{'0', '3', '7'}),
- V38(38, new byte[]{'0', '3', '8'}),
- V39(39, new byte[]{'0', '3', '9'});
+ V35(35, new byte[] {'0', '3', '5'}),
+ V37(37, new byte[] {'0', '3', '7'}),
+ V38(38, new byte[] {'0', '3', '8'}),
+ V39(39, new byte[] {'0', '3', '9'}),
+ V40(40, new byte[] {'0', '4', '0'});
private final int dexVersion;
@@ -94,15 +95,23 @@
return Optional.of(V38);
case 39:
return Optional.of(V39);
+ case 40:
+ return Optional.of(V40);
default:
return Optional.empty();
}
}
public static Optional<DexVersion> getDexVersion(char b0, char b1, char b2) {
- if (b0 != '0' || b1 != '3' || b2 < '5' || '9' < b2) {
+ if (b0 != '0') {
return Optional.empty();
}
- return getDexVersion(100 * (b0 - '0') + 10 * (b1 - '0') + (b2 - '0'));
+ for (DexVersion candidate : DexVersion.values()) {
+ assert candidate.getBytes()[0] == '0';
+ if (candidate.getBytes()[2] == b2 && candidate.getBytes()[1] == b1) {
+ return Optional.of(candidate);
+ }
+ }
+ return Optional.empty();
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 6bf0a8f..ebd5a13 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -153,6 +153,7 @@
public static final int SUPPORTED_DEX_VERSION =
AndroidApiLevel.LATEST.getDexVersion().getIntValue();
+ public static final int EXPERIMENTAL_DEX_VERSION = DexVersion.V40.getIntValue();
public static final int ASM_VERSION = Opcodes.ASM9;
@@ -1879,6 +1880,8 @@
private boolean hasReadCheckDeterminism = false;
private DeterminismChecker determinismChecker = null;
public boolean usePcEncodingInCfForTesting = false;
+ public boolean dexContainerExperiment =
+ System.getProperty("com.android.tools.r8.dexContainerExperiment") != null;
// Testing options to analyse locality of items in DEX files when they are generated.
public boolean calculateItemUseCountInDex = false;
diff --git a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
index b87a2b5..646e09e 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
@@ -179,7 +179,7 @@
FieldSignature.fromDexField(originalField, originalField.holder != originalType);
FieldSignature residualSignature = FieldSignature.fromDexField(residualField);
MemberNaming memberNaming = new MemberNaming(originalSignature, residualSignature);
- getBuilder().addMemberEntry(memberNaming, residualSignature);
+ getBuilder().addMemberEntry(memberNaming);
}
});
return this;
@@ -227,7 +227,7 @@
MethodSignature residualSignature = MethodSignature.fromDexMethod(residualMethod);
MemberNaming memberNaming = new MemberNaming(originalSignature, residualSignature);
- getBuilder().addMemberEntry(memberNaming, residualSignature);
+ getBuilder().addMemberEntry(memberNaming);
// Add simple "a() -> b" mapping if we won't have any other with concrete line numbers
if (mappedPositions.isEmpty()) {
diff --git a/src/test/examplesJava9/timeunit/Example.java b/src/test/examplesJava11/timeunit/Example.java
similarity index 85%
rename from src/test/examplesJava9/timeunit/Example.java
rename to src/test/examplesJava11/timeunit/Example.java
index 09e1d0c..003f8a4 100644
--- a/src/test/examplesJava9/timeunit/Example.java
+++ b/src/test/examplesJava11/timeunit/Example.java
@@ -4,6 +4,7 @@
package timeunit;
+import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.TimeUnit;
@@ -12,5 +13,6 @@
public static void main(String[] args) {
TimeUnit timeUnit = TimeUnit.of(ChronoUnit.NANOS);
System.out.println(timeUnit.toChronoUnit());
+ System.out.println(timeUnit.convert(Duration.ZERO));
}
}
diff --git a/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java b/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java
new file mode 100644
index 0000000..3c9713d
--- /dev/null
+++ b/src/test/examplesJava9/stringconcatfactory/StringConcatFactoryUsage.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package stringconcatfactory;
+
+public class StringConcatFactoryUsage {
+
+ public static void main(String[] args) {
+ System.out.println("Hello " + args.length);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
index 8ba7823..92604de 100644
--- a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
+++ b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.UnverifiableCfCodeDiagnostic;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -95,7 +96,9 @@
diagnostics -> {
diagnostics.assertErrorsMatch(
diagnosticMessage(containsString("java.util.concurrent.Flow$Subscriber")));
- diagnostics.assertOnlyErrors();
+ // TODO(b/251482856): Unexpected unverifiable code.
+ diagnostics.assertWarningsMatch(diagnosticType(UnverifiableCfCodeDiagnostic.class));
+ diagnostics.assertNoInfos();
if (parameters.isDexRuntime()) {
// TODO(b/175659048): This should likely be a desugar diagnostic.
diagnostics.assertErrorsMatch(diagnosticType(MissingDefinitionsDiagnostic.class));
diff --git a/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java b/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
index f7be6ca..b6f5848 100644
--- a/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
+++ b/src/test/java/com/android/tools/r8/FailCompilationOnFutureVersionsTest.java
@@ -22,7 +22,7 @@
public class FailCompilationOnFutureVersionsTest extends TestBase {
static final int UNSUPPORTED_CF_VERSION = InternalOptions.SUPPORTED_CF_VERSION.major() + 1;
- static final int UNSUPPORTED_DEX_VERSION = InternalOptions.SUPPORTED_DEX_VERSION + 1;
+ static final int UNSUPPORTED_DEX_VERSION = InternalOptions.EXPERIMENTAL_DEX_VERSION + 1;
private final TestParameters parameters;
@@ -68,6 +68,40 @@
}
@Test
+ public void testExperimentatDexVersion() throws CompilationFailedException, IOException {
+ // Generate a DEX file with a version higher than the supported one.
+ Path out =
+ testForD8()
+ .addProgramClasses(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(
+ options ->
+ options.testing.forceDexVersionBytes =
+ ("0" + InternalOptions.EXPERIMENTAL_DEX_VERSION).getBytes())
+ .compile()
+ .writeToZip();
+ try {
+ testForD8()
+ .addProgramFiles(out)
+ .setMinApi(parameters.getApiLevel())
+ .compileWithExpectedDiagnostics(
+ diagnotics -> {
+ diagnotics.assertOnlyErrors();
+ diagnotics.assertErrorsCount(1);
+ assertThat(
+ diagnotics.getErrors().get(0).getDiagnosticMessage(),
+ containsString(
+ "Dex file with version '"
+ + InternalOptions.EXPERIMENTAL_DEX_VERSION
+ + "' cannot be used with min sdk level "));
+ });
+ } catch (CompilationFailedException e) {
+ return;
+ }
+ fail("Expected compilation error");
+ }
+
+ @Test
public void testCf() {
try {
testForD8()
diff --git a/src/test/java/com/android/tools/r8/L8TestCompileResult.java b/src/test/java/com/android/tools/r8/L8TestCompileResult.java
index fd5af1c..30744c3 100644
--- a/src/test/java/com/android/tools/r8/L8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/L8TestCompileResult.java
@@ -77,7 +77,7 @@
}
public <E extends Throwable> L8TestCompileResult inspectKeepRules(
- ThrowingConsumer<List<String>, E> consumer) throws Throwable {
+ ThrowingConsumer<List<String>, E> consumer) throws E {
consumer.accept(allKeepRules);
return self();
}
diff --git a/src/test/java/com/android/tools/r8/R8CfVersionTest.java b/src/test/java/com/android/tools/r8/R8CfVersionTest.java
index fcc29c1..d7ab6c8 100644
--- a/src/test/java/com/android/tools/r8/R8CfVersionTest.java
+++ b/src/test/java/com/android/tools/r8/R8CfVersionTest.java
@@ -18,7 +18,7 @@
@RunWith(Parameterized.class)
public class R8CfVersionTest extends TestBase {
- private final CfVersion targetVersion = CfVersion.V1_8;
+ private final CfVersion targetVersion = CfVersion.V11;
@Parameters(name = "{0}")
public static TestParametersCollection data() {
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 2d25b7c..688ab43 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -178,7 +178,7 @@
"Did you forget a keep rule for the run method?", mainFeatureClassSubject, isPresent());
assertThat(
"Did you forget a keep rule for the run method?",
- mainFeatureClassSubject.uniqueMethodWithName("run"),
+ mainFeatureClassSubject.uniqueMethodWithOriginalName("run"),
isPresent());
String[] args = new String[2 + featureDependencies.length];
args[0] = mainFeatureClassSubject.getFinalName();
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index a575af1..93f6288 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -46,7 +46,6 @@
import com.android.tools.r8.jasmin.JasminBuilder;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
-import com.android.tools.r8.profile.art.ArtProfileCollection;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
@@ -174,6 +173,11 @@
return ExternalR8TestBuilder.create(new TestState(temp), backend, runtime);
}
+ public static ExternalR8TestBuilder testForExternalR8(TemporaryFolder temp, Backend backend) {
+ return ExternalR8TestBuilder.create(
+ new TestState(temp), backend, TestRuntime.getSystemRuntime());
+ }
+
public static D8TestBuilder testForD8(TemporaryFolder temp, Backend backend) {
return D8TestBuilder.create(new TestState(temp), backend);
}
@@ -214,6 +218,10 @@
return testForExternalR8(temp, backend, runtime);
}
+ public ExternalR8TestBuilder testForExternalR8(Backend backend) {
+ return testForExternalR8(temp, backend, TestRuntime.getSystemRuntime());
+ }
+
public D8TestBuilder testForD8() {
return testForD8(temp, Backend.DEX);
}
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index 165cd83..cd6df4f 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.TestBase.Backend;
import com.android.tools.r8.benchmarks.BenchmarkResults;
-import com.android.tools.r8.debug.DebugTestConfig;
import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorEventConsumer;
import com.android.tools.r8.optimize.argumentpropagation.codescanner.MethodStateCollectionByReference;
import com.android.tools.r8.testing.AndroidBuildVersion;
@@ -32,6 +31,7 @@
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
@@ -226,6 +226,18 @@
return internalCompileAndBenchmark(null);
}
+ private Collection<Path> getDefaultLibraryFiles() {
+ if (backend == Backend.DEX) {
+ assert builder.isMinApiLevelSet();
+ return Collections.singletonList(
+ ToolHelper.getFirstSupportedAndroidJar(
+ AndroidApiLevel.getAndroidApiLevel(builder.getMinApiLevel())));
+ } else {
+ assert backend == Backend.CF;
+ return Collections.singletonList(ToolHelper.getJava8RuntimeJar());
+ }
+ }
+
private CR internalCompileAndBenchmark(BenchmarkResults benchmark)
throws CompilationFailedException {
AndroidAppConsumers sink = new AndroidAppConsumers();
@@ -249,14 +261,7 @@
}
builder.setOptimizeMultidexForLinearAlloc(optimizeMultidexForLinearAlloc);
if (useDefaultRuntimeLibrary) {
- if (backend == Backend.DEX) {
- assert builder.isMinApiLevelSet();
- builder.addLibraryFiles(
- ToolHelper.getFirstSupportedAndroidJar(
- AndroidApiLevel.getAndroidApiLevel(builder.getMinApiLevel())));
- } else {
- builder.addLibraryFiles(TestBase.runtimeJar(backend));
- }
+ builder.addLibraryFiles(getDefaultLibraryFiles());
}
assertNull(oldStdout);
oldStdout = System.out;
diff --git a/src/test/java/com/android/tools/r8/TestRuntime.java b/src/test/java/com/android/tools/r8/TestRuntime.java
index 3524d63..0d937dd 100644
--- a/src/test/java/com/android/tools/r8/TestRuntime.java
+++ b/src/test/java/com/android/tools/r8/TestRuntime.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.structural.Ordered;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableMap;
@@ -28,7 +29,7 @@
public abstract class TestRuntime {
// Enum describing the possible/supported CF runtimes.
- public enum CfVm {
+ public enum CfVm implements Ordered<CfVm> {
JDK8("jdk8", 52),
JDK9("jdk9", 53),
JDK10("jdk10", 54),
@@ -66,17 +67,21 @@
}
public boolean lessThan(CfVm other) {
- return this.ordinal() < other.ordinal();
+ return isLessThan(other);
}
public boolean lessThanOrEqual(CfVm other) {
- return this.ordinal() <= other.ordinal();
+ return isLessThanOrEqualTo(other);
}
@Override
public String toString() {
return name;
}
+
+ public static CfVm getMinimumSystemVersion() {
+ return JDK11;
+ }
}
private static final Path JDK8_PATH = Paths.get(ToolHelper.THIRD_PARTY_DIR, "openjdk", "jdk8");
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
index 601208f..6b01a75 100644
--- a/src/test/java/com/android/tools/r8/TestState.java
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -12,7 +12,7 @@
public class TestState {
private final TemporaryFolder temp;
- private final TestDiagnosticMessagesImpl messages = new TestDiagnosticMessagesImpl();
+ private final TestDiagnosticMessagesImpl messages;
private Set<String> mainDexClasses;
@@ -20,7 +20,12 @@
private String stderr;
public TestState(TemporaryFolder temp) {
+ this(temp, new TestDiagnosticMessagesImpl());
+ }
+
+ public TestState(TemporaryFolder temp, TestDiagnosticMessagesImpl handler) {
this.temp = temp;
+ this.messages = handler;
}
public TemporaryFolder getTempFolder() {
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
index 1307d62..0381e87 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationProguardCompatTest.java
@@ -70,7 +70,7 @@
ClassSubject classSubject = inspector.clazz(clazzWithGetter);
assertThat(classSubject, isPresent());
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName("field");
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("field");
assertThat(fieldSubject, isPresent());
// Although this field was explicitly kept, it is no longer private.
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
index b1c5fc8..ce4dc72 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/EffectiveFinalFieldMarkedFinalTest.java
@@ -49,10 +49,10 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
assertThat(
- mainClassSubject.uniqueFieldWithName("instanceField"),
+ mainClassSubject.uniqueFieldWithOriginalName("instanceField"),
allOf(isPresent(), onlyIf(allowAccessModification, isFinal())));
assertThat(
- mainClassSubject.uniqueFieldWithName("staticField"),
+ mainClassSubject.uniqueFieldWithOriginalName("staticField"),
allOf(isPresent(), onlyIf(allowAccessModification, isFinal())));
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
index 45ddf3e..3358771 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/PackagePrivateOverridePublicizerBottomTest.java
@@ -70,7 +70,8 @@
ClassSubject subViewModelSubject =
inspector.clazz(DescriptorUtils.descriptorToJavaType(NEW_DESCRIPTOR));
assertThat(subViewModelSubject, isPresent());
- MethodSubject clearSubject = subViewModelSubject.uniqueMethodWithName("clear");
+ MethodSubject clearSubject =
+ subViewModelSubject.uniqueMethodWithOriginalName("clear");
assertThat(clearSubject, isPresent());
assertTrue(clearSubject.isPublic());
});
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
index 61c1d77..3aeeb72 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/PrivateKeptMembersPublicizerTest.java
@@ -71,11 +71,11 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
if (withKeepAllowAccessModification) {
- assertThat(classSubject.uniqueFieldWithName("greeting"), isPublic());
- assertThat(classSubject.uniqueMethodWithName("greet"), isPublic());
+ assertThat(classSubject.uniqueFieldWithOriginalName("greeting"), isPublic());
+ assertThat(classSubject.uniqueMethodWithOriginalName("greet"), isPublic());
} else {
- assertThat(classSubject.uniqueFieldWithName("greeting"), isPrivate());
- assertThat(classSubject.uniqueMethodWithName("greet"), isPrivate());
+ assertThat(classSubject.uniqueFieldWithOriginalName("greeting"), isPrivate());
+ assertThat(classSubject.uniqueMethodWithOriginalName("greet"), isPrivate());
}
}
diff --git a/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java b/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
index 59e8923..af2e5df 100644
--- a/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/annotations/DalvikAnnotationOptimizationTest.java
@@ -81,7 +81,7 @@
: ImmutableSet.of();
assertEquals(
expected,
- inspector.clazz(TestClass.class).uniqueMethodWithName("main").annotations().stream()
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main").annotations().stream()
.map(s -> s.getAnnotation().type.getDescriptor().toSourceString())
.collect(Collectors.toSet()));
}
diff --git a/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java b/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
index 8e8f4ee..97f6cd0 100644
--- a/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
+++ b/src/test/java/com/android/tools/r8/apimodel/AndroidApiVersionsXmlParser.java
@@ -86,7 +86,7 @@
getMaxAndroidApiLevelFromNode(memberNode, apiLevel));
} else if (isField(memberNode)) {
// The field do not have descriptors and are supposed to be unique.
- FieldSubject fieldSubject = clazz.uniqueFieldWithName(getName(memberNode));
+ FieldSubject fieldSubject = clazz.uniqueFieldWithOriginalName(getName(memberNode));
if (!fieldSubject.isPresent()) {
assert hasRemoved(memberNode);
assert getRemoved(memberNode).isLessThanOrEqualTo(maxApiLevel);
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
index f351779..284fbd5 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelInlineInSameClassTest.java
@@ -63,7 +63,7 @@
if (parameters.isDexRuntime()
&& parameters.getApiLevel().isGreaterThanOrEqualTo(L_MR1)) {
ClassSubject mainSubject = inspector.clazz(Main.class);
- MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithName("main");
+ MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithOriginalName("main");
assertThat(mainMethodSubject, isPresent());
assertThat(mainMethodSubject, CodeMatchers.invokesMethodWithName("apiLevel22"));
}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
index c8c4fe2..409cd9b 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeProgramDefinedDuplicateTest.java
@@ -135,8 +135,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject libraryClassSubject = inspector.clazz(LibraryClass.class);
assertThat(libraryClassSubject, isPresent());
- assertThat(libraryClassSubject.uniqueMethodWithName("foo"), isPresent());
- assertThat(libraryClassSubject.uniqueMethodWithName("bar"), isPresent());
+ assertThat(libraryClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+ assertThat(libraryClassSubject.uniqueMethodWithOriginalName("bar"), isPresent());
}
private void checkOutput(SingleTestRunResult<?> runResult) {
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
index dea3e93..b2611de 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelMockMergeTest.java
@@ -136,8 +136,8 @@
assertThat(libraryClassSubject, isAbsent());
} else {
assertThat(libraryClassSubject, isPresent());
- assertThat(libraryClassSubject.uniqueMethodWithName("foo"), isAbsent());
- assertThat(libraryClassSubject.uniqueMethodWithName("bar"), isAbsent());
+ assertThat(libraryClassSubject.uniqueMethodWithOriginalName("foo"), isAbsent());
+ assertThat(libraryClassSubject.uniqueMethodWithOriginalName("bar"), isAbsent());
}
}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
index 9a243d3..c69756a 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
@@ -67,7 +67,8 @@
assert parameters.canUseDefaultAndStaticInterfaceMethods();
assertThat(apiCaller, isPresent());
assertThat(aSubject, isPresent());
- MethodSubject callApiLevel = apiCaller.uniqueMethodWithName("callApiLevel");
+ MethodSubject callApiLevel =
+ apiCaller.uniqueMethodWithOriginalName("callApiLevel");
assertThat(callApiLevel, CodeMatchers.invokesMethodWithName("apiLevel22"));
} else {
assert parameters.isDexRuntime();
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
index ed7b9eb..e5967cd 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
@@ -77,13 +77,13 @@
} else {
assertThat(action, isPresent());
MethodSubject action$lambda$getAction$0 =
- action.uniqueMethodWithName("lambda$getAction$0");
+ action.uniqueMethodWithOriginalName("lambda$getAction$0");
assertThat(action$lambda$getAction$0, isPresent());
assertThat(
action$lambda$getAction$0, CodeMatchers.invokesMethodWithName("apiLevel22"));
assertThat(apiCaller, isPresent());
- MethodSubject callApi = apiCaller.uniqueMethodWithName("callApi");
+ MethodSubject callApi = apiCaller.uniqueMethodWithOriginalName("callApi");
assertThat(callApi, isPresent());
assertThat(callApi, CodeMatchers.invokesMethodWithName("apiLevel22"));
}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
index d974c7a..e2f517c 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningAboveMinApiTest.java
@@ -51,7 +51,8 @@
.compile()
.inspect(
inspector -> {
- FieldSubject fieldSubject = inspector.clazz(Main.class).uniqueFieldWithName("FIELD");
+ FieldSubject fieldSubject =
+ inspector.clazz(Main.class).uniqueFieldWithOriginalName("FIELD");
assertThat(fieldSubject, isPresent());
assertEquals(
ApiLevel22.class.getTypeName(), fieldSubject.getField().getType().getTypeName());
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
index 1d17e5c..aea9a60 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelTypeStrengtheningTest.java
@@ -56,7 +56,8 @@
inspector -> {
Class<?> expectedFieldType =
isTypeStrengtheningSafe ? ApiLevel23.class : ApiLevel22.class;
- FieldSubject fieldSubject = inspector.clazz(Main.class).uniqueFieldWithName("FIELD");
+ FieldSubject fieldSubject =
+ inspector.clazz(Main.class).uniqueFieldWithOriginalName("FIELD");
assertThat(fieldSubject, isPresent());
assertEquals(
expectedFieldType.getTypeName(), fieldSubject.getField().getType().getTypeName());
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
index 04cacdf..d151f76 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/KeepAbstractMethodShadowingTest.java
@@ -57,7 +57,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(B.class);
assertThat(clazz, isPresent());
- MethodSubject foo = clazz.uniqueMethodWithName("foo");
+ MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 2472119..b63a54d 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -71,7 +71,7 @@
ClassSubject classSubject = inspector.clazz(SimpleDataAdapter.class);
assertThat(classSubject, isPresent());
- MethodSubject subject = classSubject.uniqueMethodWithName("registerObserver");
+ MethodSubject subject = classSubject.uniqueMethodWithOriginalName("registerObserver");
assertThat(subject, isPresent());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
index eac0142..f0e4af3 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
@@ -91,20 +91,20 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(BridgeHoistingAccessibilityTestClasses.A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("bridgeC"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("bridgeC"), isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("bridgeB"), isPresent());
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("bridgeB"), isPresent());
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
ClassSubject axClassSubject = inspector.clazz(AWithRangedInvoke.class);
assertThat(axClassSubject, isPresent());
- assertThat(axClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(axClassSubject.uniqueMethodWithName("bridgeC"), isPresent());
+ assertThat(axClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(axClassSubject.uniqueMethodWithOriginalName("bridgeC"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
index b273533..af36954 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
@@ -71,7 +71,7 @@
assertThat(baseClassSubject, isPresent());
MethodSubject bridgeOnBaseMethodSubject =
- baseClassSubject.uniqueMethodWithName("bridge");
+ baseClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnBaseMethodSubject, isPresent());
// Inspect A. This should have the bridge method unless it is removed by the
@@ -79,7 +79,8 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject bridgeOnAMethodSubject = aClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeOnAMethodSubject =
+ aClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnAMethodSubject, notIf(isPresent(), removeBridgeMethodFromA));
// Inspect B. This should not have a bridge method, as the bridge in C is not eligible
@@ -88,17 +89,19 @@
inspector.clazz(DescriptorUtils.descriptorToJavaType(TRANSFORMED_B_DESCRIPTOR));
assertThat(bClassSubject, isPresent());
- MethodSubject bridgeMethodSubject = bClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeMethodSubject =
+ bClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeMethodSubject, isAbsent());
- MethodSubject testMethodSubject = bClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject = bClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
// Inspect C. The method C.bridge() is never eligible for hoisting.
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- MethodSubject bridgeOnCMethodSubject = cClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeOnCMethodSubject =
+ cClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnCMethodSubject, isPresent());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
index bf958f8..34ea8d3 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/FinalBridgeHoistingTest.java
@@ -56,16 +56,16 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
ClassSubject b1ClassSubject = inspector.clazz(B1.class);
assertThat(b1ClassSubject, isPresent());
- assertThat(b1ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+ assertThat(b1ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
ClassSubject b2ClassSubject = inspector.clazz(B2.class);
assertThat(b2ClassSubject, isPresent());
- assertThat(b2ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+ assertThat(b2ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
index 458a8d2..13cd7b4 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
@@ -57,11 +57,11 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("bridge"), isPresent());
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
index 02c948c..dd3f482 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
@@ -55,16 +55,16 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(NonReboundBridgeHoistingTestClasses.getClassA());
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("bridge"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
ClassSubject bClassSubject = inspector.clazz(NonReboundBridgeHoistingTestClasses.B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("bridge"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("bridge"), not(isPresent()));
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- assertThat(cClassSubject.uniqueMethodWithName("bridge"), not(isPresent()));
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("bridge"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
index ff05bfd..6264e0c 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
@@ -63,8 +63,8 @@
ClassSubject b1ClassSubject = inspector.clazz(B.class);
assertThat(b1ClassSubject, isPresent());
- assertThat(b1ClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(b1ClassSubject.uniqueMethodWithName("bridge"), isPresent());
+ assertThat(b1ClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(b1ClassSubject.uniqueMethodWithOriginalName("bridge"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
index 2ac940a..156c74b 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/PositiveBridgeHoistingTest.java
@@ -70,29 +70,29 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("superBridge"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
ClassSubject b1ClassSubject = inspector.clazz(B1.class);
assertThat(b1ClassSubject, isPresent());
- assertThat(b1ClassSubject.uniqueMethodWithName("superBridge"), not(isPresent()));
- assertThat(b1ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+ assertThat(b1ClassSubject.uniqueMethodWithOriginalName("superBridge"), not(isPresent()));
+ assertThat(b1ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
ClassSubject b2ClassSubject = inspector.clazz(B2.class);
assertThat(b2ClassSubject, isPresent());
- assertThat(b2ClassSubject.uniqueMethodWithName("superBridge"), not(isPresent()));
- assertThat(b2ClassSubject.uniqueMethodWithName("virtualBridge"), not(isPresent()));
+ assertThat(b2ClassSubject.uniqueMethodWithOriginalName("superBridge"), not(isPresent()));
+ assertThat(b2ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), not(isPresent()));
ClassSubject b4ClassSubject = inspector.clazz(B4.class);
assertThat(b4ClassSubject, isPresent());
- assertThat(b4ClassSubject.uniqueMethodWithName("superBridge"), isPresent());
- assertThat(b4ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+ assertThat(b4ClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+ assertThat(b4ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
ClassSubject b5ClassSubject = inspector.clazz(B5.class);
assertThat(b5ClassSubject, isPresent());
- assertThat(b5ClassSubject.uniqueMethodWithName("superBridge"), isPresent());
- assertThat(b5ClassSubject.uniqueMethodWithName("virtualBridge"), isPresent());
+ assertThat(b5ClassSubject.uniqueMethodWithOriginalName("superBridge"), isPresent());
+ assertThat(b5ClassSubject.uniqueMethodWithOriginalName("virtualBridge"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
index 91ddda8..a353ff8 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/SingleBridgeToPackagePrivateMethodThatOverridesPublicMethodTest.java
@@ -89,7 +89,8 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject bridgeOnAMethodSubject = aClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeOnAMethodSubject =
+ aClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnAMethodSubject, onlyIf(enableBridgeHoistingFromB, isPresent()));
// Inspect B.
@@ -97,14 +98,16 @@
inspector.clazz(DescriptorUtils.descriptorToJavaType(TRANSFORMED_B_DESCRIPTOR));
assertThat(bClassSubject, isPresent());
- MethodSubject bridgeOnBMethodSubject = bClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeOnBMethodSubject =
+ bClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnBMethodSubject, notIf(isPresent(), enableBridgeHoistingFromB));
// Inspect C.
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- MethodSubject bridgeOnCMethodSubject = cClassSubject.uniqueMethodWithName("bridge");
+ MethodSubject bridgeOnCMethodSubject =
+ cClassSubject.uniqueMethodWithOriginalName("bridge");
assertThat(bridgeOnCMethodSubject, isAbsent());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java b/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
index 07d16af..0b4e818 100644
--- a/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
+++ b/src/test/java/com/android/tools/r8/cf/GetClassLdcClassTest.java
@@ -113,7 +113,7 @@
assertTrue(
inspector
.clazz(Runner.class)
- .uniqueMethodWithName("run")
+ .uniqueMethodWithOriginalName("run")
.streamInstructions()
.anyMatch(i -> i.isConstClass(Runner.class.getTypeName())));
});
diff --git a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
index 0bdb4f8..193e5b5 100644
--- a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
@@ -101,7 +101,8 @@
private void checkPresenceOfDeserializedLambdas(CodeInspector inspector) {
for (Class<?> clazz : getClasses()) {
- MethodSubject method = inspector.clazz(clazz).uniqueMethodWithName("$deserializeLambda$");
+ MethodSubject method =
+ inspector.clazz(clazz).uniqueMethodWithOriginalName("$deserializeLambda$");
assertEquals(
"Unexpected status for $deserializedLambda$ on " + clazz.getSimpleName(),
parameters.isCfRuntime(),
diff --git a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
index 255e2be..8b0251f 100644
--- a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
+++ b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
@@ -67,7 +67,8 @@
private void checkPresenceOfDeserializedLambdas(CodeInspector inspector) {
for (Class<?> clazz : getClasses()) {
- MethodSubject method = inspector.clazz(clazz).uniqueMethodWithName("$deserializeLambda$");
+ MethodSubject method =
+ inspector.clazz(clazz).uniqueMethodWithOriginalName("$deserializeLambda$");
assertEquals(
"Unexpected status for $deserializedLambda$ on " + clazz.getSimpleName(),
parameters.isCfRuntime(),
diff --git a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
index 7c9d4ac..5927841 100644
--- a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
@@ -72,7 +72,7 @@
// L1: ; locals:
// 11: pop
ClassSubject clazz = inspector.clazz("com.android.tools.r8.cf.TryRangeTestLimitRange");
- CfCode cfCode = clazz.uniqueMethodWithName("main").getMethod().getCode().asCfCode();
+ CfCode cfCode = clazz.uniqueMethodWithOriginalName("main").getMethod().getCode().asCfCode();
List<CfInstruction> instructions = cfCode.getInstructions();
CfLabel startLabel = cfCode.getTryCatchRanges().get(0).start;
int index = 0;
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
index b26a1cf..f41ac28 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
@@ -14,10 +14,12 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.ExternalR8TestCompileResult;
+import com.android.tools.r8.JdkClassFileProvider;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.retrace.ProguardMapProducer;
@@ -56,6 +58,7 @@
"}",
"-allowaccessmodification"
};
+ private static String HELLO_EXPECTED = StringUtils.lines("Hello, world");
private static Pair<Path, Path> r8R8Debug;
private static Pair<Path, Path> r8R8Release;
@@ -75,7 +78,9 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withCfRuntimes().build();
+ return getTestParameters()
+ .withCfRuntimesStartingFromIncluding(CfVm.getMinimumSystemVersion())
+ .build();
}
public BootstrapCurrentEqualityTest(TestParameters parameters) {
@@ -87,10 +92,11 @@
final Path jar = testFolder.newFolder().toPath().resolve("out.jar");
final Path map = testFolder.newFolder().toPath().resolve("out.map");
if (testExternal) {
- testForExternalR8(newTempFolder(), Backend.CF, TestRuntime.getCheckedInJdk9())
+ testForExternalR8(newTempFolder(), Backend.CF)
.useR8WithRelocatedDeps()
.setMode(mode)
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addLibraryFiles(TestRuntime.getSystemRuntime().getJavaHome())
.addKeepRuleFiles(MAIN_KEEP)
.compile()
.apply(c -> FileUtils.writeTextFile(map, c.getProguardMap()))
@@ -99,6 +105,7 @@
testForR8(newTempFolder(), Backend.CF)
.setMode(mode)
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
.addKeepRuleFiles(MAIN_KEEP)
.compile()
.apply(c -> FileUtils.writeTextFile(map, c.getProguardMap()))
@@ -167,6 +174,7 @@
testForExternalR8(parameters.getBackend(), parameters.getRuntime())
.useProvidedR8(ToolHelper.R8LIB_JAR)
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addLibraryFiles(parameters.asCfRuntime().getJavaHome())
.addKeepRuleFiles(MAIN_KEEP)
.setMode(CompilationMode.RELEASE)
.compile()
@@ -176,6 +184,7 @@
.useProvidedR8(ToolHelper.R8LIB_EXCLUDE_DEPS_JAR)
.addR8ExternalDepsToClasspath()
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addLibraryFiles(parameters.asCfRuntime().getJavaHome())
.addKeepRuleFiles(MAIN_KEEP)
.setMode(CompilationMode.RELEASE)
.compile()
@@ -190,13 +199,15 @@
@Test
public void test() throws Exception {
- Path helloJar = Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, "hello" + JAR_EXTENSION);
- ProcessResult runResult = ToolHelper.runJava(helloJar, "hello.Hello");
- assertEquals(0, runResult.exitCode);
- compareR8(helloJar, runResult, KEEP_HELLO, "hello.Hello");
+ Path program = Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, "hello" + JAR_EXTENSION);
+ testForJvm()
+ .addProgramFiles(program)
+ .run(parameters.getRuntime(), HELLO_NAME)
+ .assertSuccessWithOutput(HELLO_EXPECTED)
+ .apply(r -> compareR8(program, HELLO_EXPECTED, KEEP_HELLO, HELLO_NAME));
}
- private void compareR8(Path program, ProcessResult runResult, String[] keep, String... args)
+ private void compareR8(Path program, String expectedOutput, String[] keep, String main)
throws Exception {
ExternalR8TestCompileResult runR8Debug =
testForExternalR8(newTempFolder(), parameters.getBackend(), parameters.getRuntime())
@@ -205,7 +216,10 @@
.addKeepRules(keep)
.setMode(CompilationMode.DEBUG)
.compile();
- assertEquals(runResult.toString(), ToolHelper.runJava(runR8Debug.outputJar(), args).toString());
+ testForJvm()
+ .addProgramFiles(runR8Debug.outputJar())
+ .run(parameters.getRuntime(), main)
+ .assertSuccessWithOutput(expectedOutput);
ExternalR8TestCompileResult runR8Release =
testForExternalR8(newTempFolder(), parameters.getBackend(), parameters.getRuntime())
.useR8WithRelocatedDeps()
@@ -213,8 +227,10 @@
.addKeepRules(keep)
.setMode(CompilationMode.RELEASE)
.compile();
- assertEquals(
- runResult.toString(), ToolHelper.runJava(runR8Release.outputJar(), args).toString());
+ testForJvm()
+ .addProgramFiles(runR8Release.outputJar())
+ .run(parameters.getRuntime(), main)
+ .assertSuccessWithOutput(expectedOutput);
RunR8AndCheck(r8R8Debug, program, runR8Debug, keep, CompilationMode.DEBUG);
RunR8AndCheck(r8R8Debug, program, runR8Release, keep, CompilationMode.RELEASE);
RunR8AndCheck(r8R8Release, program, runR8Debug, keep, CompilationMode.DEBUG);
diff --git a/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java b/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java
new file mode 100644
index 0000000..3bc8a3d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/stringconcatfactory/StringConcatFactoryTest.java
@@ -0,0 +1,169 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.cf.stringconcatfactory;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.DiagnosticsLevel;
+import com.android.tools.r8.DiagnosticsMatcher;
+import com.android.tools.r8.JdkClassFileProvider;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestState;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+import com.android.tools.r8.examples.JavaExampleClassProxy;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class StringConcatFactoryTest extends TestBase {
+
+ private static final String PKG = "stringconcatfactory";
+ private static final String EXAMPLE = "examplesJava9/" + PKG;
+ private final JavaExampleClassProxy MAIN =
+ new JavaExampleClassProxy(EXAMPLE, PKG + "/StringConcatFactoryUsage");
+
+ static final String EXPECTED = StringUtils.lines("Hello 0");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build();
+ }
+
+ public StringConcatFactoryTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private void checkInvokeDynamic(CodeInspector inspector) {
+ assertEquals(
+ parameters.isCfRuntime(),
+ inspector
+ .clazz(MAIN.typeName())
+ .uniqueMethodWithOriginalName("main")
+ .streamInstructions()
+ .anyMatch(InstructionSubject::isInvokeDynamic));
+ }
+
+ @Test
+ public void testReference() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClassFileData(MAIN.bytes())
+ .run(parameters.getRuntime(), MAIN.typeName())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkInvokeDynamic);
+ }
+
+ @Test
+ public void testJdk8NoIgnoreR8() throws Exception {
+ R8FullTestBuilder builder =
+ testForR8(parameters.getBackend())
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(MAIN.bytes())
+ // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+ .addKeepMainRule(MAIN.typeName());
+ R8TestCompileResult compileResult;
+ try {
+ compileResult =
+ builder.compileWithExpectedDiagnostics(
+ diagnostics -> {
+ if (parameters.isDexRuntime()) {
+ diagnostics.assertNoMessages();
+ } else {
+ diagnostics.assertErrorsMatch(
+ DiagnosticsMatcher.diagnosticType(MissingDefinitionsDiagnostic.class));
+ diagnostics.assertOnlyErrors();
+ }
+ });
+ } catch (CompilationFailedException e) {
+ assertTrue(parameters.isCfRuntime());
+ return;
+ }
+ assertTrue(parameters.isDexRuntime());
+ compileResult
+ .run(parameters.getRuntime(), MAIN.typeName())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkInvokeDynamic);
+ }
+
+ @Test
+ public void testJdk8WithIgnoreR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(MAIN.bytes())
+ // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+ .addKeepMainRule(MAIN.typeName())
+ .applyIf(
+ parameters.isCfRuntime(), b -> b.addDontWarn("java.lang.invoke.StringConcatFactory"))
+ .compile()
+ .run(parameters.getRuntime(), MAIN.typeName())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkInvokeDynamic);
+ }
+
+ @Test
+ public void testJdk8WithMapDiagnostic() throws Exception {
+ TestDiagnosticMessagesImpl handler =
+ new TestDiagnosticMessagesImpl() {
+ @Override
+ public DiagnosticsLevel modifyDiagnosticsLevel(
+ DiagnosticsLevel level, Diagnostic diagnostic) {
+ if (diagnostic instanceof MissingDefinitionsDiagnostic) {
+ return DiagnosticsLevel.WARNING;
+ }
+ return super.modifyDiagnosticsLevel(level, diagnostic);
+ }
+ };
+ R8FullTestBuilder.create(new TestState(temp, handler), parameters.getBackend())
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(MAIN.bytes())
+ // Always link to the JDK8 rt.jar which has no definition of StringConcatFactory.
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+ .addKeepMainRule(MAIN.typeName())
+ .allowDiagnosticWarningMessages(parameters.isCfRuntime())
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ if (parameters.isDexRuntime()) {
+ diagnostics.assertNoMessages();
+ } else {
+ diagnostics
+ .assertWarningsMatch(
+ DiagnosticsMatcher.diagnosticType(MissingDefinitionsDiagnostic.class))
+ .assertOnlyWarnings();
+ }
+ })
+ .run(parameters.getRuntime(), MAIN.typeName())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkInvokeDynamic);
+ }
+
+ @Test
+ public void testSystemJdkNoIgnoreClassesR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(MAIN.bytes())
+ // The system runtime has StringConcatFactory so link to its bootclasspath.
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
+ .addKeepMainRule(MAIN.typeName())
+ .run(parameters.getRuntime(), MAIN.typeName())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkInvokeDynamic);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java b/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
index f19d1c1..ad0af4b 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/B162969014.java
@@ -88,8 +88,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject logClassSubject = inspector.clazz(Log.class);
assertThat(logClassSubject, isPresent());
- assertThat(logClassSubject.uniqueMethodWithName("foo"), isPresent());
- assertThat(logClassSubject.uniqueMethodWithName("bar"), not(isPresent()));
+ assertThat(logClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+ assertThat(logClassSubject.uniqueMethodWithOriginalName("bar"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
index 0b2fa97..fe6cd7e 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckSubclassDiscardedEntirelyTest.java
@@ -15,8 +15,6 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.checkdiscarded.CheckClassDiscardedEntirelyTest.Main;
-import com.android.tools.r8.checkdiscarded.CheckClassDiscardedEntirelyTest.Secret;
import com.android.tools.r8.errors.CheckDiscardDiagnostic;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -105,9 +103,11 @@
ClassSubject publicClassSubject = inspector.clazz(Public.class);
assertThat(publicClassSubject, isPresent());
assertThat(
- publicClassSubject.uniqueMethodWithName("printPublic"), isPresent());
+ publicClassSubject.uniqueMethodWithOriginalName("printPublic"),
+ isPresent());
assertThat(
- publicClassSubject.uniqueMethodWithName("printPublicAllowInlining"),
+ publicClassSubject.uniqueMethodWithOriginalName(
+ "printPublicAllowInlining"),
isAbsent());
assertThat(inspector.clazz(Secret.class), isAbsent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
index 269b793..05698dc 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
@@ -12,9 +12,6 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.A;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.B;
-import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.Main;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -45,23 +42,23 @@
assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
- FieldSubject v1Subject = aClassSubject.uniqueFieldWithName("v1");
- FieldSubject v2Subject = aClassSubject.uniqueFieldWithName("v2");
+ FieldSubject v1Subject = aClassSubject.uniqueFieldWithOriginalName("v1");
+ FieldSubject v2Subject = aClassSubject.uniqueFieldWithOriginalName("v2");
- MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("getAV1");
+ MethodSubject methodSubject = aClassSubject.uniqueMethodWithOriginalName("getAV1");
assertThat(methodSubject, isPresent());
assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
- methodSubject = aClassSubject.uniqueMethodWithName("getAV2");
+ methodSubject = aClassSubject.uniqueMethodWithOriginalName("getAV2");
assertThat(methodSubject, isPresent());
assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
// The fields v1 and v2 are swapped, because their access modifiers are swapped.
- methodSubject = aClassSubject.uniqueMethodWithName("getBV1");
+ methodSubject = aClassSubject.uniqueMethodWithOriginalName("getBV1");
assertThat(methodSubject, isPresent());
assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
- methodSubject = aClassSubject.uniqueMethodWithName("getBV2");
+ methodSubject = aClassSubject.uniqueMethodWithOriginalName("getBV2");
assertThat(methodSubject, isPresent());
assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
});
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
index 93bfcef..a4dd321 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
@@ -40,7 +40,7 @@
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
- aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+ aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
assertThat(classIdFieldSubject, isPresent());
MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
index e5a169b..9f0bb44 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
@@ -49,7 +49,7 @@
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
- aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+ aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
assertThat(classIdFieldSubject, isPresent());
MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
index 61432d2..38119c1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
@@ -40,7 +40,7 @@
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
- aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+ aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
assertThat(classIdFieldSubject, isPresent());
MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
index e688559..3f32311 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
@@ -42,11 +42,11 @@
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(codeInspector.clazz(C.class), isPresent());
- FieldSubject fieldSubject = cClassSubject.uniqueFieldWithName("fieldB");
+ FieldSubject fieldSubject = cClassSubject.uniqueFieldWithOriginalName("fieldB");
assertThat(fieldSubject, isPresent());
assertThat(fieldSubject, isFieldOfType(aClassSubject.getDexProgramClass().getType()));
- fieldSubject = cClassSubject.uniqueFieldWithName("fieldArrayB");
+ fieldSubject = cClassSubject.uniqueFieldWithOriginalName("fieldArrayB");
assertThat(fieldSubject, isPresent());
assertTrue(fieldSubject.getDexField().type.isArrayType());
assertThat(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
index 817c786..1c03f26 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
@@ -42,7 +42,7 @@
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
- aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+ aClassSubject.uniqueFieldWithOriginalName(ClassMerger.CLASS_ID_FIELD_NAME);
assertThat(classIdFieldSubject, isPresent());
MethodSubject firstInitSubject = aClassSubject.init("int");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
index 5e95a1e..8709f49 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodNonTrivialMergeTest.java
@@ -47,7 +47,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("foo$bridge");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("foo$bridge");
assertThat(methodSubject, isPresent());
assertFalse(methodSubject.isFinal());
})
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
index 6287174..b0ef0f0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
@@ -46,7 +46,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("foo");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("foo");
assertThat(methodSubject, isPresent());
assertFalse(methodSubject.isFinal());
})
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
index d96c16c..3790be6 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterAbstractClassMergingTest.java
@@ -57,13 +57,15 @@
inspector -> {
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- assertThat(iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPublic()));
+ assertThat(
+ iClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isPublic()));
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
assertThat(aClassSubject, not(isImplementing(iClassSubject)));
assertThat(
- aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+ aClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), isPackagePrivate()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()", "Y.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
index 8093d0c..79b840f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonPublicOverrideOfPublicMethodAfterClassMergingTest.java
@@ -56,13 +56,15 @@
inspector -> {
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- assertThat(iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPublic()));
+ assertThat(
+ iClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isPublic()));
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
assertThat(aClassSubject, isExtending(iClassSubject));
assertThat(
- aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+ aClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), isPackagePrivate()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()", "B.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
index 4d793a4..3b1e8c1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
@@ -47,7 +47,7 @@
assertThat(aClassSubject, isPresent());
MethodSubject synchronizedMethodSubject =
- aClassSubject.uniqueMethodWithName("m$bridge");
+ aClassSubject.uniqueMethodWithOriginalName("m$bridge");
assertThat(synchronizedMethodSubject, isPresent());
assertTrue(synchronizedMethodSubject.getAccessFlags().isStrict());
@@ -55,7 +55,7 @@
assertThat(cClassSubject, isPresent());
MethodSubject unsynchronizedMethodSubject =
- cClassSubject.uniqueMethodWithName("m$bridge");
+ cClassSubject.uniqueMethodWithOriginalName("m$bridge");
assertThat(unsynchronizedMethodSubject, isPresent());
assertFalse(unsynchronizedMethodSubject.getAccessFlags().isStrict());
})
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
index 4811a41..374e568 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
@@ -47,7 +47,7 @@
assertThat(aClassSubject, isPresent());
MethodSubject synchronizedMethodSubject =
- aClassSubject.uniqueMethodWithName("m$bridge");
+ aClassSubject.uniqueMethodWithOriginalName("m$bridge");
assertThat(synchronizedMethodSubject, isPresent());
assertTrue(synchronizedMethodSubject.isSynchronized());
@@ -55,7 +55,7 @@
assertThat(cClassSubject, isPresent());
MethodSubject unsynchronizedMethodSubject =
- cClassSubject.uniqueMethodWithName("m$bridge");
+ cClassSubject.uniqueMethodWithOriginalName("m$bridge");
assertThat(unsynchronizedMethodSubject, isPresent());
assertFalse(unsynchronizedMethodSubject.isSynchronized());
})
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
index 07f3fce..3417654 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
@@ -47,12 +47,12 @@
ClassSubject parentClassSubject = codeInspector.clazz(Parent.class);
assertThat(parentClassSubject, isPresent());
// Parent#foo is renamed to Parent#foo1 to prevent collision.
- assertThat(parentClassSubject.uniqueMethodWithName("foo$1"), isPresent());
+ assertThat(parentClassSubject.uniqueMethodWithOriginalName("foo$1"), isPresent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
// C#foo is not renamed to match interface.
- assertThat(cClassSubject.uniqueMethodWithName("foo"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
ClassSubject iClassSubject = codeInspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
index 43bbf33..e346353 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
@@ -52,7 +52,7 @@
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
// C#foo is not renamed to match interface.
- assertThat(cClassSubject.uniqueMethodWithName("foo"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
ClassSubject iClassSubject = codeInspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
index f58252e..d904b01 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalOverrideAfterInterfaceMergingTest.java
@@ -58,13 +58,14 @@
inspector -> {
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- assertThat(iClassSubject.uniqueMethodWithName("m"), isAbsent());
+ assertThat(iClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
assertThat(aClassSubject, isImplementing(iClassSubject));
assertThat(
- aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+ aClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), isPackagePrivate()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()", "B.m()");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
index 420ccaa..d4094c5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/IllegalSiblingAfterInterfaceMergingTest.java
@@ -59,12 +59,13 @@
inspector -> {
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- assertThat(iClassSubject.uniqueMethodWithName("m"), isAbsent());
+ assertThat(iClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
ClassSubject a0ClassSubject = inspector.clazz(A0.class);
assertThat(a0ClassSubject, isPresent());
assertThat(
- a0ClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isPackagePrivate()));
+ a0ClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), isPackagePrivate()));
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java b/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
index 5ab767d..6156017 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/B141942381.java
@@ -70,10 +70,10 @@
ClassSubject boxImpl = inspector.clazz(BoxImpl.class);
assertThat(boxImpl, isPresent());
- FieldSubject storage = boxImpl.uniqueFieldWithName("_storage");
+ FieldSubject storage = boxImpl.uniqueFieldWithOriginalName("_storage");
assertThat(storage, isPresent());
- MethodSubject set = boxImpl.uniqueMethodWithName("set");
+ MethodSubject set = boxImpl.uniqueMethodWithOriginalName("set");
assertThat(set, isPresent());
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
index da6cb32..1f9e6c7 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
@@ -53,7 +53,6 @@
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
-import java.util.function.Function;
import java.util.function.Predicate;
import org.junit.Assume;
import org.junit.Test;
@@ -540,7 +539,7 @@
.toString()
.equals("java.lang.String classmerging.ProguardFieldMapTest$A.f")
&& fieldNaming
- .computeResidualSignature(Function.identity())
+ .getResidualSignature()
.toString()
.equals("java.lang.String f")));
}
@@ -588,10 +587,7 @@
methodNaming
.getOriginalSignature()
.toString()
- .equals(
- methodNaming
- .computeResidualSignature(Function.identity())
- .toString())));
+ .equals(methodNaming.getResidualSignature().toString())));
// Try with vertical class merging.
Set<String> preservedClassNames =
@@ -624,7 +620,7 @@
.toString()
.equals("void classmerging.ProguardMethodMapTest$A.method()")
&& methodNaming
- .computeResidualSignature(Function.identity())
+ .getResidualSignature()
.toString()
.equals("void method$classmerging$ProguardMethodMapTest$A()")));
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
index d4d1355..69d794e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
@@ -56,7 +56,7 @@
assertEquals(
"<T:Ljava/lang/Object;>L" + binaryName(A.class) + "<Ljava/lang/Object;>;",
classSubject.getFinalSignatureAttribute());
- MethodSubject bar = classSubject.uniqueMethodWithName("bar");
+ MethodSubject bar = classSubject.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresentAndRenamed());
assertEquals("(TT;)V", bar.getFinalSignatureAttribute());
// The NeverInline is transferred to the private vertically merged method but also
diff --git a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
index dba64d3..a733112 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/CompatKeepClassMemberNamesTestRunner.java
@@ -91,11 +91,11 @@
}
private static void assertBarGetInstanceIsNotInlined(CodeInspector inspector) {
- assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithName("instance").isPresent());
+ assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("instance").isPresent());
assertTrue(
inspector
.clazz(MAIN_CLASS)
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.anyMatch(i -> i.isInvoke() && i.getMethod().qualifiedName().contains("instance")));
}
@@ -154,8 +154,9 @@
assertTrue(inspector.clazz(MAIN_CLASS).isPresent());
assertTrue(inspector.clazz(BAR_CLASS).isPresent());
assertBarGetInstanceIsNotInlined(inspector);
- assertTrue(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i").isPresent());
- assertTrue(inspector.clazz(BAR_CLASS).uniqueMethodWithName("<init>").isPresent());
+ assertTrue(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i").isPresent());
+ assertTrue(
+ inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("<init>").isPresent());
})
.run(parameters.getRuntime(), MAIN_CLASS)
.assertSuccessWithOutput(EXPECTED);
@@ -184,7 +185,7 @@
assertTrue(inspector.clazz(BAR_CLASS).isPresent());
assertBarGetInstanceIsNotInlined(inspector);
assertThat(inspector.clazz(BAR_CLASS).init(), isPresent());
- assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i"), isPresent());
+ assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i"), isPresent());
});
}
@@ -256,13 +257,13 @@
// Bar is renamed but its member names are kept.
ClassSubject bar = inspector.clazz(BAR_CLASS);
assertTrue(bar.isRenamed());
- FieldSubject barI = bar.uniqueFieldWithName("i");
+ FieldSubject barI = bar.uniqueFieldWithOriginalName("i");
assertTrue(barI.isPresent());
assertFalse(barI.isRenamed());
- MethodSubject barInit = bar.uniqueMethodWithName("<init>");
+ MethodSubject barInit = bar.uniqueMethodWithOriginalName("<init>");
assertTrue(barInit.isPresent());
assertFalse(barInit.isRenamed());
- MethodSubject barInstance = bar.uniqueMethodWithName("instance");
+ MethodSubject barInstance = bar.uniqueMethodWithOriginalName("instance");
assertTrue(barInstance.isPresent());
assertFalse(barInstance.isRenamed());
})
@@ -296,8 +297,9 @@
assertTrue(inspector.clazz(MAIN_CLASS).isPresent());
assertTrue(inspector.clazz(BAR_CLASS).isPresent());
assertBarGetInstanceIsNotInlined(inspector);
- assertThat(inspector.clazz(BAR_CLASS).uniqueMethodWithName("<init>"), isPresent());
- assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithName("i"), isPresent());
+ assertThat(
+ inspector.clazz(BAR_CLASS).uniqueMethodWithOriginalName("<init>"), isPresent());
+ assertThat(inspector.clazz(BAR_CLASS).uniqueFieldWithOriginalName("i"), isPresent());
});
}
@@ -356,10 +358,10 @@
assertBarGetInstanceIsNotInlined(inspector);
ClassSubject bar = inspector.clazz(BAR_CLASS);
assertTrue(bar.isPresent());
- assertTrue(bar.uniqueMethodWithName("instance").isPresent());
+ assertTrue(bar.uniqueMethodWithOriginalName("instance").isPresent());
// Reflected on fields are not kept.
- assertFalse(bar.uniqueMethodWithName("<init>").isPresent());
- assertFalse(bar.uniqueFieldWithName("i").isPresent());
+ assertFalse(bar.uniqueMethodWithOriginalName("<init>").isPresent());
+ assertFalse(bar.uniqueFieldWithOriginalName("i").isPresent());
})
.run(parameters.getRuntime(), MAIN_CLASS)
// Keeping the instance and its accessed members does not keep the reflected <init> and i.
@@ -414,9 +416,9 @@
ClassSubject bar = inspector.clazz(BAR_CLASS);
assertTrue(bar.isPresent());
assertTrue(bar.isRenamed());
- assertFalse(bar.uniqueFieldWithName("i").isPresent());
- assertFalse(bar.uniqueMethodWithName("<init>").isPresent());
- MethodSubject barInstance = bar.uniqueMethodWithName("instance");
+ assertFalse(bar.uniqueFieldWithOriginalName("i").isPresent());
+ assertFalse(bar.uniqueMethodWithOriginalName("<init>").isPresent());
+ MethodSubject barInstance = bar.uniqueMethodWithOriginalName("instance");
assertTrue(barInstance.isPresent());
assertFalse(barInstance.isRenamed());
})
diff --git a/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java b/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
index 009cf9f..70aaa93 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/KeepClassMemberNamesMinificationTest.java
@@ -78,8 +78,8 @@
inspector -> {
ClassSubject aClass = inspector.clazz(A.class);
assertThat(aClass, isPresentAndRenamed());
- assertThat(aClass.uniqueFieldWithName("foo"), isPresentAndNotRenamed());
- assertThat(aClass.uniqueMethodWithName("foo"), isPresentAndNotRenamed());
+ assertThat(aClass.uniqueFieldWithOriginalName("foo"), isPresentAndNotRenamed());
+ assertThat(aClass.uniqueMethodWithOriginalName("foo"), isPresentAndNotRenamed());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Hello World!", "Hello World!");
diff --git a/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java b/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
index 0f82a73..4c7b46c 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/KeepRuleConnectivesTestRunner.java
@@ -41,21 +41,22 @@
RR extends TestRunResult<RR>,
T extends TestShrinkerBuilder<C, B, CR, RR, T>>
void testKeepIsDisjunction(TestShrinkerBuilder<C, B, CR, RR, T> builder) throws Exception {
- builder
- .addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
- .addKeepRules("-keep class * { public long foo(); public long bar(); }")
- .compile()
- .inspect(inspector -> {
+ builder
+ .addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
+ .addKeepRules("-keep class * { public long foo(); public long bar(); }")
+ .compile()
+ .inspect(
+ inspector -> {
ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
ClassSubject justFoo = inspector.clazz(JustFoo.class);
ClassSubject justBar = inspector.clazz(JustBar.class);
assertTrue(bothFooAndBar.isPresent());
- assertTrue(bothFooAndBar.uniqueMethodWithName("foo").isPresent());
- assertTrue(bothFooAndBar.uniqueMethodWithName("bar").isPresent());
+ assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("foo").isPresent());
+ assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("bar").isPresent());
assertTrue(justFoo.isPresent());
- assertTrue(justFoo.uniqueMethodWithName("foo").isPresent());
+ assertTrue(justFoo.uniqueMethodWithOriginalName("foo").isPresent());
assertTrue(justBar.isPresent());
- assertTrue(justBar.uniqueMethodWithName("bar").isPresent());
+ assertTrue(justBar.uniqueMethodWithOriginalName("bar").isPresent());
});
}
@@ -86,16 +87,17 @@
.addProgramClassesAndInnerClasses(KeepRuleConnectivesTest.class)
.addKeepRules("-keepclasseswithmembers class * { public long foo(); public long bar(); }")
.compile()
- .inspect(inspector -> {
- ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
- ClassSubject justFoo = inspector.clazz(JustFoo.class);
- ClassSubject justBar = inspector.clazz(JustBar.class);
- assertTrue(bothFooAndBar.isPresent());
- assertTrue(bothFooAndBar.uniqueMethodWithName("foo").isPresent());
- assertTrue(bothFooAndBar.uniqueMethodWithName("bar").isPresent());
- assertFalse(justFoo.isPresent());
- assertFalse(justBar.isPresent());
- });
+ .inspect(
+ inspector -> {
+ ClassSubject bothFooAndBar = inspector.clazz(BothFooAndBar.class);
+ ClassSubject justFoo = inspector.clazz(JustFoo.class);
+ ClassSubject justBar = inspector.clazz(JustBar.class);
+ assertTrue(bothFooAndBar.isPresent());
+ assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("foo").isPresent());
+ assertTrue(bothFooAndBar.uniqueMethodWithOriginalName("bar").isPresent());
+ assertFalse(justFoo.isPresent());
+ assertFalse(justBar.isPresent());
+ });
}
@Test
diff --git a/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java b/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
index 5a17702..11c8aed 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/assertionconfiguration/AssertionConfigurationTest.java
@@ -75,7 +75,7 @@
assertTrue(
new CodeInspector(output)
.clazz(MockClassWithAssertion.class)
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.anyMatch(this::invokesAssertionHandler));
}
diff --git a/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java b/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
index 962cec0..f09071f 100644
--- a/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/d8/DuplicateAnnotationTest.java
@@ -93,7 +93,7 @@
ClassSubject testA = inspector.clazz(TestA.class);
assertThat(testA, isPresent());
- MethodSubject foo = testA.uniqueMethodWithName("foo");
+ MethodSubject foo = testA.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
AnnotationSubject annotation = foo.annotation(TestKeep.class.getName());
assertThat(annotation, isPresent());
@@ -110,17 +110,17 @@
ClassSubject testB = inspector.clazz(TestB.class);
assertThat(testB, isPresent());
- FieldSubject instance = testB.uniqueFieldWithName("instance");
+ FieldSubject instance = testB.uniqueFieldWithOriginalName("instance");
assertThat(instance, isPresent());
annotation = instance.annotation(TestKeep.class.getName());
assertThat(annotation, isPresent());
- foo = testB.uniqueMethodWithName("foo");
+ foo = testB.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
annotation = foo.annotation(TestKeep.class.getName());
assertThat(annotation, isPresent());
- MethodSubject bar = testB.uniqueMethodWithName("bar");
+ MethodSubject bar = testB.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresent());
annotation = bar.annotation(TestKeep.class.getName());
assertThat(annotation, isPresent());
diff --git a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
index a8eb9cc..053f4b3 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
@@ -67,7 +67,7 @@
result.inspect(
inspector -> {
DexEncodedMethod method =
- inspector.clazz(ClassA.class).uniqueMethodWithName("call").getMethod();
+ inspector.clazz(ClassA.class).uniqueMethodWithOriginalName("call").getMethod();
DexDebugInfo debugInfo = method.getCode().asDexCode().getDebugInfo();
assertNull(debugInfo);
});
diff --git a/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
index f3a22bf..c6f0994 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/EnsureNoDebugInfoEmittedForPcOnlyTestRunner.java
@@ -137,13 +137,13 @@
private void checkNoDebugInfo(CodeInspector inspector, int expectedMethodsInMain) {
ClassSubject clazz = inspector.clazz(MAIN);
assertEquals(expectedMethodsInMain, clazz.allMethods().size());
- MethodSubject main = clazz.uniqueMethodWithName("main");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
assertNull(main.getMethod().getCode().asDexCode().getDebugInfo());
}
private void checkHasLineNumberInfo(CodeInspector inspector) {
ClassSubject clazz = inspector.clazz(MAIN);
- MethodSubject main = clazz.uniqueMethodWithName("main");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
List<DexDebugEntry> entries =
new DexDebugEntryBuilder(main.getMethod(), inspector.getFactory()).build();
Set<Integer> lines = entries.stream().map(e -> e.line).collect(Collectors.toSet());
diff --git a/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java b/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
index ccdac2d..377df99 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/NopLineRegression230337727Test.java
@@ -41,7 +41,8 @@
.run(parameters.getRuntime(), TestClass.class)
.inspect(
inspector -> {
- MethodSubject foo = inspector.clazz(TestClass.class).uniqueMethodWithName("foo");
+ MethodSubject foo =
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.getLineNumberTable().getLines().toString(),
foo.getLineNumberTable().getLines().contains(11));
diff --git a/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java b/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
index 596707f..46d76ca 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/Regress233857593Test.java
@@ -38,7 +38,7 @@
1,
inspector
.clazz(TestClass.class)
- .uniqueMethodWithName("testLoopPhiWithNullFirstInput")
+ .uniqueMethodWithOriginalName("testLoopPhiWithNullFirstInput")
.streamInstructions()
.filter(InstructionSubject::isGoto)
.count()));
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
index f83d077..c577259 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
@@ -67,9 +67,9 @@
assertThat(stackTrace, isSame(expectedStackTrace));
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
- assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+ assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+ mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
notIf(hasLineNumberTable(), parameters.isDexRuntime()));
});
}
@@ -91,9 +91,9 @@
assertThat(stackTrace, isSame(expectedStackTrace));
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
- assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+ assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+ mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
notIf(hasLineNumberTable(), parameters.isDexRuntime()));
});
}
@@ -115,9 +115,9 @@
assertThat(stackTrace, isSame(expectedStackTrace));
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
- assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+ assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+ mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
notIf(hasLineNumberTable(), parameters.isDexRuntime()));
});
}
@@ -139,9 +139,9 @@
assertThat(stackTrace, isSame(expectedStackTrace));
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
- assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+ assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+ mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumberForInline"),
// TODO(b/146565491): Update to allow dropping the table once supported by ART.
hasLineNumberTable());
});
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
index d7a5df3..542cfb6 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
@@ -70,10 +70,11 @@
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForMultipleInvokes"),
+ mainSubject.uniqueMethodWithOriginalName(
+ "shouldRemoveLineNumberForMultipleInvokes"),
notIf(hasLineNumberTable(), parameters.isDexRuntime()));
assertThat(
- mainSubject.uniqueMethodWithName("main"),
+ mainSubject.uniqueMethodWithOriginalName("main"),
notIf(hasLineNumberTable(), parameters.isDexRuntime()));
});
}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
index bc0d012..c547357 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
@@ -67,9 +67,9 @@
assertThat(stackTrace, isSame(expectedStackTrace));
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
- assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+ assertThat(mainSubject.uniqueMethodWithOriginalName("inlinee"), not(isPresent()));
assertThat(
- mainSubject.uniqueMethodWithName("shouldNotRemoveLineNumberForInline"),
+ mainSubject.uniqueMethodWithOriginalName("shouldNotRemoveLineNumberForInline"),
notIf(
hasLineNumberTable(),
parameters.isDexRuntime()
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
index b881f55..8076acf 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
@@ -92,7 +92,7 @@
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresent());
assertThat(
- mainSubject.uniqueMethodWithName("shouldRemoveLineNumber"),
+ mainSubject.uniqueMethodWithOriginalName("shouldRemoveLineNumber"),
notIf(hasLineNumberTable(), canSingleLineDebugInfoBeDiscarded()));
});
}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
index 0bbdf46..0cc3e5b 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/SharedPc2PcDebugInfo.java
@@ -57,7 +57,7 @@
// normal encodings.
DexDebugInfo shared = null;
for (String name : METHODS) {
- DexEncodedMethod method = clazz.uniqueMethodWithName(name).getMethod();
+ DexEncodedMethod method = clazz.uniqueMethodWithOriginalName(name).getMethod();
DexDebugInfo debugInfo = method.getCode().asDexCode().getDebugInfo();
assertTrue(debugInfo.isPcBasedInfo());
// The DEX parser should allocate the same shared instance to each method.
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
index 23436d3..9fd70ef 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
@@ -75,7 +75,7 @@
assertEquals(
testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
+ testClassSubject.uniqueMethodWithOriginalName(enclosingMethod.name.toString()),
isPresent());
}
});
@@ -90,8 +90,8 @@
String outer = DesugarLambdaWithAnonymousClass.class.getTypeName();
ClassSubject testClass = inspector.clazz(outer + "$TestClass");
assertThat(testClass, isPresent());
- assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
- assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
+ assertThat(testClass.uniqueMethodWithOriginalName("lambda$test$0"), isPresent());
+ assertThat(testClass.uniqueMethodWithOriginalName("lambda$testStatic$1"), isPresent());
assertThat(inspector.clazz(outer + "$TestClass$1"), isPresent());
assertThat(inspector.clazz(outer + "$TestClass$2"), isPresent());
}
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
index 60fde2f..76eb3d7 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
@@ -73,7 +73,7 @@
assertEquals(
testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
+ testClassSubject.uniqueMethodWithOriginalName(enclosingMethod.name.toString()),
isPresent());
}
});
@@ -88,8 +88,8 @@
String outer = DesugarLambdaWithLocalClass.class.getTypeName();
ClassSubject testClass = inspector.clazz(outer + "$TestClass");
assertThat(testClass, isPresent());
- assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
- assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
+ assertThat(testClass.uniqueMethodWithOriginalName("lambda$test$0"), isPresent());
+ assertThat(testClass.uniqueMethodWithOriginalName("lambda$testStatic$1"), isPresent());
assertThat(inspector.clazz(outer + "$TestClass$1MyConsumerImpl"), isPresent());
assertThat(inspector.clazz(outer + "$TestClass$2MyConsumerImpl"), isPresent());
}
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
index 9444833..b1fae08 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
@@ -61,7 +61,8 @@
}
private void checkBackportingNotRequired(CodeInspector inspector) {
- MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+ MethodSubject methodSubject =
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main");
if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
assertTrue(code.getInstructions().stream().noneMatch(this::isCfLAdd));
@@ -73,7 +74,8 @@
}
private void checkBackportingRequired(CodeInspector inspector) {
- MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+ MethodSubject methodSubject =
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main");
if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
assertTrue(code.getInstructions().stream().anyMatch(this::isCfLAdd));
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
index 8524f5d..f90490d 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
@@ -140,7 +140,9 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(TestRunner.class).uniqueMethodWithName(jacocoBootstrapMethodName),
+ inspector
+ .clazz(TestRunner.class)
+ .uniqueMethodWithOriginalName(jacocoBootstrapMethodName),
isAbsent());
})
.assertSuccessWithOutputLines("No " + jacocoBootstrapMethodName + " method");
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
index 6b61085..872ca85 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
@@ -80,7 +80,8 @@
if (compilationSpecification.isProgramShrink()) {
return;
}
- MethodSubject direct = inspector.clazz(Executor.class).uniqueMethodWithName("directTypes");
+ MethodSubject direct =
+ inspector.clazz(Executor.class).uniqueMethodWithOriginalName("directTypes");
if (libraryDesugaringSpecification.hasEmulatedInterfaceDesugaring(parameters)) {
assertTrue(
direct
@@ -95,7 +96,7 @@
assertTrue(direct.streamInstructions().noneMatch(instr -> instr.toString().contains("$-EL")));
}
MethodSubject inherited =
- inspector.clazz(Executor.class).uniqueMethodWithName("inheritedTypes");
+ inspector.clazz(Executor.class).uniqueMethodWithOriginalName("inheritedTypes");
if (!libraryDesugaringSpecification.hasEmulatedInterfaceDesugaring(parameters)) {
assertTrue(
inherited.streamInstructions().noneMatch(instr -> instr.toString().contains("$-EL")));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
index 8d8f669..d6ede8b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
@@ -118,7 +118,7 @@
}
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- MethodSubject main = classSubject.uniqueMethodWithName("main");
+ MethodSubject main = classSubject.uniqueMethodWithOriginalName("main");
Set<String> foundInvokeHolders =
main.streamInstructions()
.filter(InstructionSubject::isInvoke)
@@ -177,7 +177,7 @@
.isGreaterThanOrEqualTo(TestBase.apiLevelWithDefaultInterfaceMethodsSupport())
|| isR8) {
assertThat(
- inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithName("query"),
+ inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithOriginalName("query"),
not(isPresent()));
} else {
assertThat(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
index 2f146bb..db9a6f1 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
@@ -69,7 +69,7 @@
assertEquals(
function,
classSubject
- .uniqueMethodWithName("applyFunction")
+ .uniqueMethodWithOriginalName("applyFunction")
.getMethod()
.getReference()
.proto
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
index 23a13b6..6951b62 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilOptionalTest.java
@@ -65,7 +65,7 @@
assertThat(classSubject, isPresent());
Iterator<InvokeInstructionSubject> iterator =
classSubject
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.iterateInstructions(InstructionSubject::isInvokeStatic);
assertTrue(iterator.next().holder().is("j$.util.Optional"));
assertTrue(iterator.next().holder().is("j$.util.Optional"));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
index a3f36be..0cf1b01 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoDesugaredLibraryDexFileTest.java
@@ -64,8 +64,10 @@
}
private void assertNoForwardingStreamMethod(CodeInspector inspector) {
- assertTrue(inspector.clazz(CustomArrayList.class).uniqueMethodWithName("stream").isAbsent());
- assertTrue(inspector.clazz(CustomSortedSet.class).uniqueMethodWithName("stream").isAbsent());
+ assertTrue(
+ inspector.clazz(CustomArrayList.class).uniqueMethodWithOriginalName("stream").isAbsent());
+ assertTrue(
+ inspector.clazz(CustomSortedSet.class).uniqueMethodWithOriginalName("stream").isAbsent());
}
static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
index c799716..a695eba 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
@@ -61,8 +61,10 @@
}
private void assertNoForwardingStreamMethod(CodeInspector inspector) {
- assertTrue(inspector.clazz(CustomArrayList.class).uniqueMethodWithName("stream").isAbsent());
- assertTrue(inspector.clazz(CustomSortedSet.class).uniqueMethodWithName("stream").isAbsent());
+ assertTrue(
+ inspector.clazz(CustomArrayList.class).uniqueMethodWithOriginalName("stream").isAbsent());
+ assertTrue(
+ inspector.clazz(CustomSortedSet.class).uniqueMethodWithOriginalName("stream").isAbsent());
}
static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
index 2306edf..bd8d7c5 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
@@ -202,95 +202,95 @@
: "java.util.function.Supplier";
assertThat(
- testClass.uniqueMethodWithName("objectsCompare"),
+ testClass.uniqueMethodWithOriginalName("objectsCompare"),
onlyIf(invokeJavaUtilObjects, invokesObjectsCompare("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsCompare"),
+ testClass.uniqueMethodWithOriginalName("objectsCompare"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsCompare("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsDeepEquals"),
+ testClass.uniqueMethodWithOriginalName("objectsDeepEquals"),
onlyIf(invokeJavaUtilObjects, invokesObjectsDeepEquals("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsDeepEquals"),
+ testClass.uniqueMethodWithOriginalName("objectsDeepEquals"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsDeepEquals("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsEquals"),
+ testClass.uniqueMethodWithOriginalName("objectsEquals"),
onlyIf(invokeJavaUtilObjects, invokesObjectsEquals("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsEquals"),
+ testClass.uniqueMethodWithOriginalName("objectsEquals"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsEquals("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsHash"),
+ testClass.uniqueMethodWithOriginalName("objectsHash"),
onlyIf(invokeJavaUtilObjects, invokesObjectsHash("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsHash"),
+ testClass.uniqueMethodWithOriginalName("objectsHash"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsHash("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsHashCode"),
+ testClass.uniqueMethodWithOriginalName("objectsHashCode"),
onlyIf(invokeJavaUtilObjects, invokesObjectsHashCode("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsHashCode"),
+ testClass.uniqueMethodWithOriginalName("objectsHashCode"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsHashCode("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNull"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNull"),
onlyIf(invokeJavaUtilObjects, invokesObjectsRequireNonNull("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNull"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNull"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsRequireNonNull("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNullWithMessage"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithMessage"),
onlyIf(
invokeJavaUtilObjects, invokesObjectsRequireNonNullWithMessage("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNullWithMessage"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithMessage"),
onlyIf(
invokeJDollarUtilObjects, invokesObjectsRequireNonNullWithMessage("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNullWithSupplier"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithSupplier"),
onlyIf(
invokeJavaUtilObjectsWithSupplier,
invokesObjectsRequireNonNullWithSupplier("java.util.Objects", supplier)));
assertThat(
- testClass.uniqueMethodWithName("objectsRequireNonNullWithSupplier"),
+ testClass.uniqueMethodWithOriginalName("objectsRequireNonNullWithSupplier"),
onlyIf(
invokeJDollarUtilObjectsWithSupplier,
invokesObjectsRequireNonNullWithSupplier("j$.util.Objects", supplier)));
assertThat(
- testClass.uniqueMethodWithName("objectsToString"),
+ testClass.uniqueMethodWithOriginalName("objectsToString"),
onlyIf(invokeJavaUtilObjects, invokesObjectsToString("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsToString"),
+ testClass.uniqueMethodWithOriginalName("objectsToString"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsToString("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsToStringWithNullDefault"),
+ testClass.uniqueMethodWithOriginalName("objectsToStringWithNullDefault"),
onlyIf(invokeJavaUtilObjects, invokesObjectsToStringWithNullDefault("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsToStringWithNullDefault"),
+ testClass.uniqueMethodWithOriginalName("objectsToStringWithNullDefault"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsToStringWithNullDefault("j$.util.Objects")));
invokeJavaUtilObjects = parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
assertThat(
- testClass.uniqueMethodWithName("objectsIsNull"),
+ testClass.uniqueMethodWithOriginalName("objectsIsNull"),
onlyIf(invokeJavaUtilObjects, invokesObjectsIsNull("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsIsNull"),
+ testClass.uniqueMethodWithOriginalName("objectsIsNull"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsIsNull("j$.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsNonNull"),
+ testClass.uniqueMethodWithOriginalName("objectsNonNull"),
onlyIf(invokeJavaUtilObjects, invokesObjectsNonNull("java.util.Objects")));
assertThat(
- testClass.uniqueMethodWithName("objectsNonNull"),
+ testClass.uniqueMethodWithOriginalName("objectsNonNull"),
onlyIf(invokeJDollarUtilObjects, invokesObjectsNonNull("j$.util.Objects")));
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
index 51222b2..535da2a 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
@@ -144,7 +144,7 @@
assertThat(classSubject, isPresent());
List<InstructionSubject> invokes =
classSubject
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.filter(instr -> instr.isInvokeInterface() || instr.isInvokeStatic())
.collect(Collectors.toList());
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
index 91721e2..bf335b8 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetAndBackportTest.java
@@ -79,7 +79,7 @@
assertTrue(
inspector
.clazz("j$.time.Duration")
- .uniqueMethodWithName("toMillis")
+ .uniqueMethodWithOriginalName("toMillis")
.streamInstructions()
.filter(InstructionSubject::isInvokeStatic)
.map(InstructionSubject::toString)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
index 1009f56..91669ae 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
@@ -84,7 +84,7 @@
ClassSubject mapClass = inspector.clazz("j$.util.concurrent.ConcurrentHashMap");
if (parameters.getApiLevel().isLessThan(AndroidApiLevel.N)) {
assertTrue(mapClass.isPresent());
- FieldSubject serialVersionUID = mapClass.uniqueFieldWithName("serialVersionUID");
+ FieldSubject serialVersionUID = mapClass.uniqueFieldWithOriginalName("serialVersionUID");
assertTrue(serialVersionUID.isPresent());
} else {
assertFalse(mapClass.isPresent());
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
index 54b3bc9..2e2e8fb 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/TimeUnitTest.java
@@ -5,16 +5,17 @@
package com.android.tools.r8.desugar.desugaredlibrary.jdk11;
import static com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification.DEFAULT_SPECIFICATIONS;
-import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.getJdk8Jdk11;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_PATH;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
import com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification;
import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
@@ -31,18 +32,15 @@
private final CompilationSpecification compilationSpecification;
private static final Path INPUT_JAR =
- Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR + "timeunit.jar");
- private static final String EXPECTED_OUTPUT = StringUtils.lines("Nanos");
+ Paths.get(ToolHelper.EXAMPLES_JAVA11_JAR_DIR + "timeunit.jar");
+ private static final String EXPECTED_OUTPUT = StringUtils.lines("Nanos", "0");
private static final String MAIN_CLASS = "timeunit.Example";
@Parameters(name = "{0}, spec: {1}, {2}")
public static List<Object[]> data() {
return buildParameters(
- getTestParameters()
- .withDexRuntimesStartingFromIncluding(Version.V13_0_0)
- .withApiLevel(AndroidApiLevel.B)
- .build(),
- getJdk8Jdk11(),
+ getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+ ImmutableList.of(JDK11, JDK11_PATH),
DEFAULT_SPECIFICATIONS);
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
index b67d511..6ef6b8b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
@@ -38,6 +38,7 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Function;
import org.junit.Assume;
@@ -344,14 +345,16 @@
builder.addLibraryFiles(libraryDesugaringSpecification.getLibraryFiles());
}
- public DesugaredLibraryTestCompileResult<T> compile() throws Exception {
+ public DesugaredLibraryTestCompileResult<T> compile()
+ throws CompilationFailedException, IOException, ExecutionException {
prepareCompilation();
TestCompileResult<?, ? extends SingleTestRunResult<?>> compile = builder.compile();
return internalCompile(compile);
}
public DesugaredLibraryTestCompileResult<T> compileWithExpectedDiagnostics(
- DiagnosticsConsumer consumer) throws Exception {
+ DiagnosticsConsumer consumer)
+ throws CompilationFailedException, IOException, ExecutionException {
prepareCompilation();
TestCompileResult<?, ? extends SingleTestRunResult<?>> compile =
builder.compileWithExpectedDiagnostics(consumer);
@@ -359,7 +362,8 @@
}
private DesugaredLibraryTestCompileResult<T> internalCompile(
- TestCompileResult<?, ? extends SingleTestRunResult<?>> compile) throws Exception {
+ TestCompileResult<?, ? extends SingleTestRunResult<?>> compile)
+ throws CompilationFailedException, IOException, ExecutionException {
L8TestCompileResult l8Compile = compileDesugaredLibrary(compile, keepRuleConsumer);
D8TestCompileResult customLibCompile = compileCustomLib();
return new DesugaredLibraryTestCompileResult<>(
@@ -382,7 +386,7 @@
private L8TestCompileResult compileDesugaredLibrary(
TestCompileResult<?, ? extends SingleTestRunResult<?>> compile,
KeepRuleConsumer keepRuleConsumer)
- throws Exception {
+ throws CompilationFailedException, IOException, ExecutionException {
if (!compilationSpecification.isL8Shrink()) {
return compileDesugaredLibrary(null);
}
@@ -401,7 +405,8 @@
return compileDesugaredLibrary(keepRules);
}
- private L8TestCompileResult compileDesugaredLibrary(String keepRule) throws Exception {
+ private L8TestCompileResult compileDesugaredLibrary(String keepRule)
+ throws CompilationFailedException, IOException, ExecutionException {
assert !compilationSpecification.isL8Shrink() || keepRule != null;
return test.testForL8(parameters.getApiLevel(), parameters.getBackend())
.apply(
@@ -427,7 +432,8 @@
}
public String collectKeepRulesWithTraceReferences(
- Path desugaredProgramClassFile, Path desugaredLibraryClassFile) throws Exception {
+ Path desugaredProgramClassFile, Path desugaredLibraryClassFile)
+ throws CompilationFailedException, IOException {
Path generatedKeepRules = test.temp.newFile().toPath();
ArrayList<String> args = new ArrayList<>();
args.add("--keep-rules");
@@ -449,12 +455,12 @@
}
public SingleTestRunResult<?> run(TestRuntime runtime, Class<?> mainClass, String... args)
- throws Exception {
+ throws ExecutionException, IOException, CompilationFailedException {
return compile().run(runtime, mainClass.getTypeName(), args);
}
public SingleTestRunResult<?> run(TestRuntime runtime, String mainClass, String... args)
- throws Exception {
+ throws ExecutionException, IOException, CompilationFailedException {
return compile().run(runtime, mainClass, args);
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
index bd11465..3172876 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
@@ -18,6 +18,7 @@
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
public class DesugaredLibraryTestCompileResult<T extends DesugaredLibraryTestBase> {
@@ -41,7 +42,7 @@
CompilationSpecification compilationSpecification,
D8TestCompileResult customLibCompile,
L8TestCompileResult l8Compile)
- throws Exception {
+ throws CompilationFailedException, IOException {
this.test = test;
this.compileResult = compileResult;
this.parameters = parameters;
@@ -53,26 +54,26 @@
}
public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectCustomLib(
- ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+ ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
assert customLibCompile != null;
customLibCompile.inspect(consumer);
return this;
}
public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectL8(
- ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+ ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
l8Compile.inspect(consumer);
return this;
}
public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspect(
- ThrowingConsumer<CodeInspector, E> consumer) throws Throwable {
+ ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
compileResult.inspect(consumer);
return this;
}
public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectKeepRules(
- ThrowingConsumer<List<String>, E> consumer) throws Throwable {
+ ThrowingConsumer<List<String>, E> consumer) throws E {
if (compilationSpecification.isL8Shrink()) {
l8Compile.inspectKeepRules(consumer);
}
@@ -80,21 +81,21 @@
}
public <E extends Throwable> DesugaredLibraryTestCompileResult<T> apply(
- ThrowingConsumer<DesugaredLibraryTestCompileResult<T>, E> consumer) throws Throwable {
+ ThrowingConsumer<DesugaredLibraryTestCompileResult<T>, E> consumer) throws E {
consumer.accept(this);
return this;
}
- public CodeInspector customLibInspector() throws Throwable {
+ public CodeInspector customLibInspector() throws IOException {
assert customLibCompile != null;
return customLibCompile.inspector();
}
- public CodeInspector l8Inspector() throws Throwable {
+ public CodeInspector l8Inspector() throws IOException {
return l8Compile.inspector();
}
- public CodeInspector inspector() throws Throwable {
+ public CodeInspector inspector() throws IOException {
return compileResult.inspector();
}
@@ -105,17 +106,17 @@
}
public SingleTestRunResult<?> run(TestRuntime runtime, Class<?> mainClass, String... args)
- throws Exception {
+ throws ExecutionException, IOException {
return run(runtime, mainClass.getTypeName(), args);
}
public SingleTestRunResult<?> run(TestRuntime runtime, String mainClassName, String... args)
- throws Exception {
+ throws ExecutionException, IOException {
return runnableCompiledResult.run(runtime, mainClassName, args);
}
private TestCompileResult<?, ? extends SingleTestRunResult<?>> computeRunnableCompiledResult()
- throws Exception {
+ throws CompilationFailedException, IOException {
TestCompileResult<?, ? extends SingleTestRunResult<?>> runnable = convertToDexIfNeeded();
if (customLibCompile != null) {
runnable.addRunClasspathFiles(customLibCompile.writeToZip());
diff --git a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
index 5e4e61a..7ee4955 100644
--- a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
+++ b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
@@ -44,13 +44,13 @@
assertTrue(
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("f")
+ .uniqueMethodWithOriginalName("f")
.streamInstructions()
.noneMatch(InstructionSubject::isInvokeVirtual));
assertTrue(
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("g")
+ .uniqueMethodWithOriginalName("g")
.streamInstructions()
.noneMatch(InstructionSubject::isInvokeVirtual));
}
@@ -62,7 +62,7 @@
1,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("f")
+ .uniqueMethodWithOriginalName("f")
.streamInstructions()
.filter(InstructionSubject::isInvokeInterface)
.count());
@@ -70,7 +70,7 @@
2,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("f")
+ .uniqueMethodWithOriginalName("f")
.streamInstructions()
.filter(InstructionSubject::isInvokeVirtual)
.count());
@@ -78,7 +78,7 @@
2,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("g")
+ .uniqueMethodWithOriginalName("g")
.streamInstructions()
.filter(InstructionSubject::isInvokeInterface)
.count());
@@ -86,7 +86,7 @@
2,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("g")
+ .uniqueMethodWithOriginalName("g")
.streamInstructions()
.filter(InstructionSubject::isInvokeInterface)
.count());
@@ -94,7 +94,7 @@
invokeVirtualCount,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("g")
+ .uniqueMethodWithOriginalName("g")
.streamInstructions()
.filter(InstructionSubject::isInvokeVirtual)
.count());
@@ -102,7 +102,7 @@
getClassCount,
inspector
.clazz(Jdk8272564.Main.typeName())
- .uniqueMethodWithName("g")
+ .uniqueMethodWithOriginalName("g")
.streamInstructions()
.filter(InstructionSubject::isInvoke)
.filter(instruction -> instruction.getMethod().getName().toString().equals("getClass"))
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
index 61b75de..5802f93 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaMethodsWithModifiedAccessTest.java
@@ -50,16 +50,20 @@
new CodeInspector(ToolHelper.getClassFileForTestClass(LambdaTest.class));
inspector.forAllClasses(clazz -> clazz.forAllMethods(System.out::println));
assertThat(
- inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_PUBLIC), isPrivate());
+ inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_PUBLIC),
+ isPrivate());
assertThat(
- inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_NATIVE), isPrivate());
+ inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_NATIVE),
+ isPrivate());
}
private void inspect(CodeInspector inspector) {
assertThat(
- inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_PUBLIC), isPublic());
+ inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_PUBLIC),
+ isPublic());
assertThat(
- inspector.clazz(LambdaTest.class).uniqueMethodWithName(LAMBDA_TO_NATIVE), isNative());
+ inspector.clazz(LambdaTest.class).uniqueMethodWithOriginalName(LAMBDA_TO_NATIVE),
+ isNative());
}
@Test
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
index b3d4ca5..34fec39 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeInterfaceTest.java
@@ -94,15 +94,15 @@
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.run(parameters.getRuntime(), "HostImpl")
.assertFailureWithErrorThatThrows(IllegalAccessError.class);
@@ -126,7 +126,7 @@
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
})
.writeToZip();
@@ -142,7 +142,7 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
})
.writeToZip();
@@ -158,7 +158,7 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.writeToZip();
@@ -182,15 +182,15 @@
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.run(parameters.getRuntime(), "HostImpl")
.assertFailureWithErrorThatThrows(IllegalAccessError.class);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
index 4d47a29..715989f 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesInDexRewriteInvokeVirtualTest.java
@@ -80,19 +80,19 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("main")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.run(parameters.getRuntime(), "Host")
.assertFailureWithErrorThatThrows(IllegalAccessError.class);
@@ -116,11 +116,11 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("main")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
})
.writeToZip();
@@ -136,7 +136,7 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
})
.writeToZip();
@@ -152,7 +152,7 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.writeToZip();
@@ -167,19 +167,19 @@
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("main")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("main")));
assertEquals(
2,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host").uniqueMethodWithName("h1")));
+ inspector.clazz("Host").uniqueMethodWithOriginalName("h1")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member1").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member1").uniqueMethodWithOriginalName("m")));
assertEquals(
1,
nonConstructorInvokeDirectCount(
- inspector.clazz("Host$Member2").uniqueMethodWithName("m")));
+ inspector.clazz("Host$Member2").uniqueMethodWithOriginalName("m")));
})
.run(parameters.getRuntime(), "Host")
.assertFailureWithErrorThatThrows(IllegalAccessError.class);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
index a235beb..155d082 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
@@ -84,13 +84,13 @@
method.toString().contains("nestPvtCallToInline")
|| method.toString().contains("methodWithPvtCallToInline")));
// Inlining nest access should transform virtual/ift invokes -> direct.
- MethodSubject methodSubject = subj.uniqueMethodWithName("dispatchInlining");
+ MethodSubject methodSubject = subj.uniqueMethodWithOriginalName("dispatchInlining");
if (methodSubject.isPresent()) {
nbDispatchInlining++;
assertTrue(
methodSubject.streamInstructions().noneMatch(InstructionSubject::isInvokeVirtual));
}
- methodSubject = subj.uniqueMethodWithName("notInlinedPvtCall");
+ methodSubject = subj.uniqueMethodWithOriginalName("notInlinedPvtCall");
if (methodSubject.isPresent()) {
nbNotInlinedPvtCall++;
}
diff --git a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
index e1d397a..e4386e4 100644
--- a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/SuppressedExceptionsTest.java
@@ -60,14 +60,14 @@
DesugarTestConfiguration::isDesugared,
inspector ->
hasInvokesTo(
- inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
"getSuppressed",
apiLevelHasSuppressedExceptionsSupport() ? 1 : 0))
.inspectIf(
DesugarTestConfiguration::isNotDesugared,
inspector ->
hasInvokesTo(
- inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
"getSuppressed",
1));
}
@@ -87,7 +87,7 @@
.inspect(
inspector -> {
hasInvokesTo(
- inspector.clazz(TestClass.class).uniqueMethodWithName("main"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("main"),
"getSuppressed",
apiLevelHasSuppressedExceptionsSupport() ? 1 : 0);
IntBox gets = new IntBox(0);
diff --git a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
index 62d5240..8ff8ca2 100644
--- a/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/suppressedexceptions/TwrSuppressedExceptionsTest.java
@@ -84,7 +84,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(MAIN.typeName());
hasInvokesTo(
- clazz.uniqueMethodWithName("bar"),
+ clazz.uniqueMethodWithOriginalName("bar"),
"$closeResource",
apiLevelHasTwrCloseResourceSupport() ? 4 : 0);
if (apiLevelHasSuppressedExceptionsSupport()) {
@@ -103,7 +103,7 @@
DesugarTestConfiguration::isNotDesugared,
inspector -> {
ClassSubject clazz = inspector.clazz(MAIN.typeName());
- hasInvokesTo(clazz.uniqueMethodWithName("bar"), "$closeResource", 4);
+ hasInvokesTo(clazz.uniqueMethodWithOriginalName("bar"), "$closeResource", 4);
hasInvokesTo(clazz.mainMethod(), "getSuppressed", 1);
});
}
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
index 46bfd05..a753b6c 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultMethodResolvingToLibraryTest.java
@@ -38,7 +38,7 @@
assertTrue(
inspector
.clazz(B.class)
- .uniqueMethodWithName("compose")
+ .uniqueMethodWithOriginalName("compose")
.streamInstructions()
.filter(InstructionSubject::isInvoke)
.map(invoke -> invoke.getMethod().getHolderType().toString())
diff --git a/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java b/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
index 90cf068..e09c293 100644
--- a/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
+++ b/src/test/java/com/android/tools/r8/dex/DebugByteCodeWriterTest.java
@@ -51,6 +51,7 @@
GlobalSyntheticsStrategy.forNonSynthesizing()));
return new ObjectToOffsetMapping(
appView,
+ null,
new LensCodeRewriterUtils(appView),
Collections.emptyList(),
Collections.emptyList(),
diff --git a/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java b/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java
new file mode 100644
index 0000000..af1ee96
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dex/container/DexContainerFormatBasicTest.java
@@ -0,0 +1,182 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.dex.container;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.maindexlist.MainDexListTests;
+import com.android.tools.r8.transformers.ClassTransformer;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class DexContainerFormatBasicTest extends TestBase {
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ private static Path inputA;
+ private static Path inputB;
+
+ @BeforeClass
+ public static void generateTestApplications() throws Throwable {
+ // Build two applications in different packages both with required multidex due to number
+ // of methods.
+ inputA = getStaticTemp().getRoot().toPath().resolve("application_a.jar");
+ inputB = getStaticTemp().getRoot().toPath().resolve("application_b.jar");
+
+ generateApplication(inputA, "a", 10);
+ generateApplication(inputB, "b", 10);
+ }
+
+ @Test
+ public void testNonContainerD8() throws Exception {
+ Path outputA =
+ testForD8(Backend.DEX)
+ .addProgramFiles(inputA)
+ .setMinApi(AndroidApiLevel.L)
+ .compile()
+ .writeToZip();
+ assertEquals(2, unzipContent(outputA).size());
+
+ Path outputB =
+ testForD8(Backend.DEX)
+ .addProgramFiles(inputB)
+ .setMinApi(AndroidApiLevel.L)
+ .compile()
+ .writeToZip();
+ assertEquals(2, unzipContent(outputB).size());
+
+ Path outputMerged =
+ testForD8(Backend.DEX)
+ .addProgramFiles(outputA, outputB)
+ .setMinApi(AndroidApiLevel.L)
+ .compile()
+ .writeToZip();
+ assertEquals(4, unzipContent(outputMerged).size());
+ }
+
+ @Test
+ public void testD8Experiment() throws Exception {
+ Path outputFromDexing =
+ testForD8(Backend.DEX)
+ .addProgramFiles(inputA)
+ .setMinApi(AndroidApiLevel.L)
+ .addOptionsModification(
+ options -> options.getTestingOptions().dexContainerExperiment = true)
+ .compile()
+ .writeToZip();
+ List<byte[]> dexFromDexing = unzipContent(outputFromDexing);
+ assertEquals(1, dexFromDexing.size());
+ }
+
+ @Test
+ public void testD8Experiment2() throws Exception {
+ Path outputA =
+ testForD8(Backend.DEX)
+ .addProgramFiles(inputA)
+ .setMinApi(AndroidApiLevel.L)
+ .addOptionsModification(
+ options -> options.getTestingOptions().dexContainerExperiment = true)
+ .compile()
+ .writeToZip();
+ assertEquals(1, unzipContent(outputA).size());
+
+ Path outputB =
+ testForD8(Backend.DEX)
+ .addProgramFiles(inputB)
+ .setMinApi(AndroidApiLevel.L)
+ .addOptionsModification(
+ options -> options.getTestingOptions().dexContainerExperiment = true)
+ .compile()
+ .writeToZip();
+ assertEquals(1, unzipContent(outputB).size());
+ }
+
+ private List<byte[]> unzipContent(Path zip) throws IOException {
+ List<byte[]> result = new ArrayList<>();
+ ZipUtils.iter(zip, (entry, inputStream) -> result.add(ByteStreams.toByteArray(inputStream)));
+ return result;
+ }
+
+ private static void generateApplication(Path applicationJar, String rootPackage, int methodCount)
+ throws Throwable {
+ ImmutableList.Builder<String> builder = ImmutableList.builder();
+ for (int i = 0; i < 10000; ++i) {
+ String pkg = rootPackage + "." + (i % 2 == 0 ? "a" : "b");
+ String className = "Class" + i;
+ builder.add(pkg + "." + className);
+ }
+ List<String> classes = builder.build();
+
+ generateApplication(applicationJar, classes, methodCount);
+ }
+
+ private static void generateApplication(Path output, List<String> classes, int methodCount)
+ throws IOException {
+ ArchiveConsumer consumer = new ArchiveConsumer(output);
+ for (String typename : classes) {
+ String descriptor = DescriptorUtils.javaTypeToDescriptor(typename);
+ byte[] bytes =
+ transformer(MainDexListTests.ClassStub.class)
+ .setClassDescriptor(descriptor)
+ .addClassTransformer(
+ new ClassTransformer() {
+ @Override
+ public MethodVisitor visitMethod(
+ int access,
+ String name,
+ String descriptor,
+ String signature,
+ String[] exceptions) {
+ // This strips <init>() too.
+ if (name.equals("methodStub")) {
+ for (int i = 0; i < methodCount; i++) {
+ MethodVisitor mv =
+ super.visitMethod(
+ access, "method" + i, descriptor, signature, exceptions);
+ mv.visitCode();
+ mv.visitInsn(Opcodes.RETURN);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ }
+ }
+ return null;
+ }
+ })
+ .transform();
+ consumer.accept(ByteDataView.of(bytes), descriptor, null);
+ }
+ consumer.finished(null);
+ }
+
+ // Simple stub/template for generating the input classes.
+ public static class ClassStub {
+ public static void methodStub() {}
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
index f56464c..bf5614e 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterFieldTypeStrengtheningTest.java
@@ -55,7 +55,8 @@
ClassSubject baseSuperClassSubject = inspector.clazz(BaseSuperClass.class);
assertThat(baseSuperClassSubject, isPresent());
- FieldSubject fieldSubject = baseSuperClassSubject.uniqueFieldWithName("f");
+ FieldSubject fieldSubject =
+ baseSuperClassSubject.uniqueFieldWithOriginalName("f");
assertThat(fieldSubject, isPresent());
assertEquals(
Object.class.getTypeName(),
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
index a7fef57..af67cbb 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
@@ -60,7 +60,7 @@
r8TestCompileResult -> {
// Ensure that isEarly from BaseUtilClass is inlined into the feature
ClassSubject clazz = r8TestCompileResult.inspector().clazz(BaseUtilClass.class);
- assertThat(clazz.uniqueMethodWithName("isEarly"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("isEarly"), not(isPresent()));
};
ProcessResult processResult =
testR8Splitter(
diff --git a/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java b/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
index 52aafa3..cceb957 100644
--- a/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
+++ b/src/test/java/com/android/tools/r8/dump/DumpInputsTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -37,7 +36,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withCfRuntime(CfVm.JDK9).build();
+ return getTestParameters().withSystemRuntime().build();
}
public DumpInputsTest(TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java
new file mode 100644
index 0000000..24743b6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceAssignmentOutsideTest.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** This is a regression for b/247146910. */
+@RunWith(Parameterized.class)
+public class EnumImplementingInterfaceAssignmentOutsideTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final EnumKeepRules enumKeepRules;
+
+ private final String[] EXPECTED = new String[] {"Bar", "Hello World!"};
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public EnumImplementingInterfaceAssignmentOutsideTest(
+ TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters)
+ .addInnerClasses(EnumImplementingInterfaceAssignmentOutsideTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines(EXPECTED);
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ // TODO(b/247146910): We should not fail compilation. If running without assertions this
+ // inserts throw null for the code.
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ testForR8(parameters.getBackend())
+ .addInnerClasses(EnumImplementingInterfaceAssignmentOutsideTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepRules(enumKeepRules.getKeepRules())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .compile());
+ }
+
+ public interface I {
+
+ String get();
+ }
+
+ @NeverClassInline
+ public enum OtherEnum implements I {
+ C("Foo"),
+ D("Bar");
+
+ private final String value;
+
+ OtherEnum(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String get() {
+ return value;
+ }
+ }
+
+ @NeverClassInline
+ public enum MyEnum {
+ A(),
+ B();
+
+ public I otherEnum;
+ }
+
+ public static class Main implements I {
+
+ public static void main(String[] args) throws Exception {
+ setInterfaceValue(System.currentTimeMillis() == 0 ? OtherEnum.C : OtherEnum.D);
+ System.out.println(MyEnum.A.otherEnum.get());
+ System.out.println(new Main().get());
+ }
+
+ private static void setInterfaceValue(I i) {
+ if (System.currentTimeMillis() > 0) {
+ MyEnum.A.otherEnum = i;
+ } else {
+ MyEnum.B.otherEnum = i;
+ }
+ }
+
+ @Override
+ public String get() {
+ if (System.currentTimeMillis() == 0) {
+ throw new RuntimeException("Foo");
+ }
+ return "Hello World!";
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java
new file mode 100644
index 0000000..be45f4c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumImplementingInterfaceTest.java
@@ -0,0 +1,115 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** This is a regression for b/247146910. */
+@RunWith(Parameterized.class)
+public class EnumImplementingInterfaceTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final EnumKeepRules enumKeepRules;
+
+ private final String[] EXPECTED = new String[] {"Foo", "Hello World!"};
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public EnumImplementingInterfaceTest(
+ TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters)
+ .addInnerClasses(EnumImplementingInterfaceTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines(EXPECTED);
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ // TODO(b/247146910): We should not fail compilation. If running without assertions this
+ // inserts throw null for the code.
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ testForR8(parameters.getBackend())
+ .addInnerClasses(EnumImplementingInterfaceTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepRules(enumKeepRules.getKeepRules())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .compile());
+ }
+
+ public interface I {
+
+ String get();
+ }
+
+ @NeverClassInline
+ public enum OtherEnum implements I {
+ C("Foo"),
+ D("Bar");
+
+ private final String value;
+
+ OtherEnum(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String get() {
+ return value;
+ }
+ }
+
+ @NeverClassInline
+ public enum MyEnum {
+ A(OtherEnum.C),
+ B(OtherEnum.D);
+
+ public I otherEnum;
+
+ MyEnum(I otherEnum) {
+ this.otherEnum = otherEnum;
+ if (System.currentTimeMillis() == 0) {
+ this.otherEnum = null;
+ }
+ }
+ }
+
+ public static class Main implements I {
+
+ public static void main(String[] args) throws Exception {
+ System.out.println(MyEnum.A.otherEnum.get());
+ System.out.println(new Main().get());
+ }
+
+ @Override
+ public String get() {
+ if (System.currentTimeMillis() == 0) {
+ throw new RuntimeException("Foo");
+ }
+ return "Hello World!";
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
index 12dfd1f..b9b1e42 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
@@ -66,11 +66,12 @@
if (parameters.isCfRuntime()) {
// There is no class staticizer in Cf.
assertThat(
- codeInspector.clazz(Companion.class).uniqueMethodWithName(renamedMethodName),
+ codeInspector.clazz(Companion.class).uniqueMethodWithOriginalName(renamedMethodName),
isPresent());
return;
}
- MethodSubject method = codeInspector.clazz(Companion.class).uniqueMethodWithName("method");
+ MethodSubject method =
+ codeInspector.clazz(Companion.class).uniqueMethodWithOriginalName("method");
assertThat(method, isPresent());
assertEquals("int", method.getMethod().getParameters().toString());
}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
index 19aa6fe..52e4a53 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
@@ -87,7 +87,8 @@
inspector.clazz(InstanceFieldPutObject.class).getDexProgramClass().instanceFields().size());
assertEquals(
1, inspector.clazz(StaticFieldPutObject.class).getDexProgramClass().staticFields().size());
- assertTrue(inspector.clazz(FailingPhi.class).uniqueMethodWithName("switchOn").isPresent());
+ assertTrue(
+ inspector.clazz(FailingPhi.class).uniqueMethodWithOriginalName("switchOn").isPresent());
}
static class InstanceFieldPutObject {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
index 670e3b3..8b67ed9 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
@@ -66,7 +66,7 @@
}
assertTrue(
i.clazz(Switch.class)
- .uniqueMethodWithName("switchOnEnumManyCases")
+ .uniqueMethodWithOriginalName("switchOnEnumManyCases")
.streamInstructions()
.anyMatch(InstructionSubject::isSwitch));
}
diff --git a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
index 86176a0..16daaac 100644
--- a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
@@ -148,7 +148,7 @@
// Testing FieldTypeSignature
//
- FieldSubject yyInZZ = zz.uniqueFieldWithName("yy");
+ FieldSubject yyInZZ = zz.uniqueFieldWithOriginalName("yy");
assertThat(yyInZZ, isPresent());
DexEncodedField field = yyInZZ.getField();
assertNotNull(field);
@@ -165,7 +165,7 @@
//
// A$Y$YY newYY([B<T>)
- MethodSubject newYY = zz.uniqueMethodWithName("newYY");
+ MethodSubject newYY = zz.uniqueMethodWithOriginalName("newYY");
assertThat(newYY, isPresent());
method = newYY.getMethod();
assertNotNull(method);
@@ -207,7 +207,7 @@
assertEquals(b.getDexProgramClass().type, classTypeSignature.type);
// Function<A$Y$ZZ<TT>, A$Y$YY> convertToYY(Supplier<A$Y$ZZ<TT>>
- MethodSubject convertToYY = zz.uniqueMethodWithName("convertToYY");
+ MethodSubject convertToYY = zz.uniqueMethodWithOriginalName("convertToYY");
assertThat(convertToYY, isPresent());
method = convertToYY.getMethod();
assertNotNull(method);
@@ -243,7 +243,7 @@
check_supplier(factory, a, y, zz, parameterSignature);
// void boo(Supplier<A$Y$ZZ<TT>>)
- MethodSubject boo = zz.uniqueMethodWithName("boo");
+ MethodSubject boo = zz.uniqueMethodWithOriginalName("boo");
assertThat(boo, isPresent());
method = boo.getMethod();
assertNotNull(method);
@@ -295,11 +295,11 @@
}
private void check_A_Y_foo_bar_baz(ClassSubject y, AppView<AppInfoWithLiveness> appView) {
- checkMethodWildCard(y.uniqueMethodWithName("foo"), appView, WildcardIndicator.POSITIVE);
- checkMethodWildCard(y.uniqueMethodWithName("bar"), appView, WildcardIndicator.NEGATIVE);
+ checkMethodWildCard(y.uniqueMethodWithOriginalName("foo"), appView, WildcardIndicator.POSITIVE);
+ checkMethodWildCard(y.uniqueMethodWithOriginalName("bar"), appView, WildcardIndicator.NEGATIVE);
// Check for star
checkFieldTypeSignature(
- y.uniqueMethodWithName("baz").asFoundMethodSubject(),
+ y.uniqueMethodWithOriginalName("baz").asFoundMethodSubject(),
appView,
typeSignature -> {
assertTrue(typeSignature.isStar());
diff --git a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
index 333ab92..2d8035e 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoHorizontalClassMerging;
@@ -11,6 +12,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.UnverifiableCfCodeDiagnostic;
import com.android.tools.r8.utils.codeinspector.AssertUtils;
import java.io.IOException;
import org.junit.Test;
@@ -76,7 +78,9 @@
.compileWithExpectedDiagnostics(
diagnostics ->
diagnostics
- .assertOnlyErrors()
+ .assertNoInfos()
+ // TODO(b/251482856): Is this an expected unverifiable code?
+ .assertWarningsMatch(diagnosticType(UnverifiableCfCodeDiagnostic.class))
.inspectErrors(
diagnostic ->
diagnostic
diff --git a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
index 48877b9..efc246f 100644
--- a/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
+++ b/src/test/java/com/android/tools/r8/graph/genericsignature/GenericSignatureKeepAttributesTest.java
@@ -107,7 +107,7 @@
ClassSubject innerClass = inspector.clazz(Inner.class);
assertThat(innerClass, isPresent());
- MethodSubject testMethod = innerClass.uniqueMethodWithName("test");
+ MethodSubject testMethod = innerClass.uniqueMethodWithOriginalName("test");
assertThat(testMethod, isPresent());
if (isCompat) {
assertEquals("(TO;TM;)TI;", testMethod.getFinalSignatureAttribute());
diff --git a/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java b/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
index 8256c29..c77d3a3 100644
--- a/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/graph/initializedclasses/InitializedClassesInInstanceMethodsTest.java
@@ -69,9 +69,9 @@
// In any case, Outer.hello(), Outer.world(), and Outer.exclamationMark() should be inlined into
// the accessibility bridges.
- assertThat(outerClassSubject.uniqueMethodWithName("hello"), not(isPresent()));
- assertThat(outerClassSubject.uniqueMethodWithName("world"), not(isPresent()));
- assertThat(outerClassSubject.uniqueMethodWithName("exclamationMark"), not(isPresent()));
+ assertThat(outerClassSubject.uniqueMethodWithOriginalName("hello"), not(isPresent()));
+ assertThat(outerClassSubject.uniqueMethodWithOriginalName("world"), not(isPresent()));
+ assertThat(outerClassSubject.uniqueMethodWithOriginalName("exclamationMark"), not(isPresent()));
int numberOfExpectedAccessibilityBridges = 0;
assertEquals(
@@ -81,19 +81,19 @@
.size());
assertEquals(
!enableInitializedClassesInInstanceMethodsAnalysis,
- outerClassSubject.uniqueFieldWithName("$r8$clinit").isPresent());
+ outerClassSubject.uniqueFieldWithOriginalName("$r8$clinit").isPresent());
ClassSubject aClassSubject = inspector.clazz(Outer.A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("hello"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("hello"), isPresent());
ClassSubject bClassSubject = inspector.clazz(Outer.B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("world"), isPresent());
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("world"), isPresent());
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- assertThat(cClassSubject.uniqueMethodWithName("exclamationMark"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("exclamationMark"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
index 262f164..de44d1c 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
@@ -191,7 +191,7 @@
assertThat(generatedMessageLiteClassSubject, isPresent());
MethodSubject isInitializedMethodSubject =
- generatedMessageLiteClassSubject.uniqueMethodWithName("isInitialized");
+ generatedMessageLiteClassSubject.uniqueMethodWithOriginalName("isInitialized");
DexType methodToInvokeType =
outputInspector.clazz(METHOD_TO_INVOKE_ENUM).getDexProgramClass().getType();
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
index 51acd65..dbfb40f 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
@@ -23,7 +23,6 @@
import com.google.common.collect.ImmutableSet;
import java.nio.file.Path;
import java.util.List;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -154,45 +153,57 @@
{
ClassSubject usedRootClassSubject = inputInspector.clazz(USED_ROOT);
assertThat(usedRootClassSubject, isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldA_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldB_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("myOneof_"), isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("recursiveWithRequiredField_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("isExtendedWithOptional_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("isExtendedWithScalars_"), isPresent());
+ usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldA_"), isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isExtendedWithRequiredField_"), isPresent());
+ usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldB_"), isPresent());
+ assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("myOneof_"), isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isRepeatedlyExtendedWithRequiredField_"),
+ usedRootClassSubject.uniqueFieldWithOriginalName("recursiveWithRequiredField_"),
isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasMapField_"), isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithOptional_"), isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithScalars_"), isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithRequiredField_"),
+ isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName(
+ "isRepeatedlyExtendedWithRequiredField_"),
+ isPresent());
+ assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("hasMapField_"), isPresent());
ClassSubject hasRequiredFieldClassSubject = inputInspector.clazz(HAS_REQUIRED_FIELD);
assertThat(hasRequiredFieldClassSubject, isPresent());
- assertThat(hasRequiredFieldClassSubject.uniqueFieldWithName("value_"), isPresent());
+ assertThat(hasRequiredFieldClassSubject.uniqueFieldWithOriginalName("value_"), isPresent());
}
// Verify the existence of various fields in the output.
{
ClassSubject usedRootClassSubject = outputInspector.clazz(USED_ROOT);
assertThat(usedRootClassSubject, isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldA_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasRequiredFieldB_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("myOneof_"), isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("recursiveWithRequiredField_"), isPresent());
- assertThat(usedRootClassSubject.uniqueFieldWithName("hasMapField_"), isPresent());
+ usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldA_"), isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName("hasRequiredFieldB_"), isPresent());
+ assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("myOneof_"), isPresent());
+ assertThat(
+ usedRootClassSubject.uniqueFieldWithOriginalName("recursiveWithRequiredField_"),
+ isPresent());
+ assertThat(usedRootClassSubject.uniqueFieldWithOriginalName("hasMapField_"), isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isExtendedWithRequiredField_"), isPresent());
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithRequiredField_"),
+ isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isRepeatedlyExtendedWithRequiredField_"),
+ usedRootClassSubject.uniqueFieldWithOriginalName(
+ "isRepeatedlyExtendedWithRequiredField_"),
isPresent());
ClassSubject hasRequiredFieldClassSubject = outputInspector.clazz(HAS_REQUIRED_FIELD);
assertThat(hasRequiredFieldClassSubject, isPresent());
- assertThat(hasRequiredFieldClassSubject.uniqueFieldWithName("value_"), isPresent());
+ assertThat(hasRequiredFieldClassSubject.uniqueFieldWithOriginalName("value_"), isPresent());
}
// Verify the absence of various fields in the output.
@@ -200,9 +211,11 @@
ClassSubject usedRootClassSubject = outputInspector.clazz(USED_ROOT);
assertThat(usedRootClassSubject, isPresent());
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isExtendedWithOptional_"), not(isPresent()));
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithOptional_"),
+ not(isPresent()));
assertThat(
- usedRootClassSubject.uniqueFieldWithName("isExtendedWithScalars_"), not(isPresent()));
+ usedRootClassSubject.uniqueFieldWithOriginalName("isExtendedWithScalars_"),
+ not(isPresent()));
}
}
@@ -221,13 +234,16 @@
ClassSubject generatedExtensionRegistryLoader = inputInspector.clazz(extensionRegistryName);
assertThat(generatedExtensionRegistryLoader, isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber"),
isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber1"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber1"),
isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber2"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber2"),
isPresent());
}
@@ -240,13 +256,16 @@
ClassSubject generatedExtensionRegistryLoader = outputInspector.clazz(extensionRegistryName);
assertThat(generatedExtensionRegistryLoader, isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber"),
isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber1"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber1"),
isPresent());
assertThat(
- generatedExtensionRegistryLoader.uniqueMethodWithName("findLiteExtensionByNumber2"),
+ generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
+ "findLiteExtensionByNumber2"),
notIf(isPresent(), enableMinification));
}
@@ -268,45 +287,48 @@
{
ClassSubject cfofClassSubject = inputInspector.clazz(CONTAINS_FLAGGED_OFF_FIELD);
assertThat(cfofClassSubject, isPresent());
- assertThat(cfofClassSubject.uniqueFieldWithName("conditionallyUsed_"), isPresent());
+ assertThat(cfofClassSubject.uniqueFieldWithOriginalName("conditionallyUsed_"), isPresent());
ClassSubject puClassSubject = inputInspector.clazz(PARTIALLY_USED);
assertThat(puClassSubject, isPresent());
assertEquals(7, puClassSubject.allInstanceFields().size());
- assertThat(puClassSubject.uniqueFieldWithName("bitField0_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("unusedEnum_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedEnum_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("unusedMessage_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedMessage_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedEnum_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedEnum_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedMessage_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedMessage_"), isPresent());
ClassSubject uvhClassSubject = inputInspector.clazz(USED_VIA_HAZZER);
assertThat(uvhClassSubject, isPresent());
- assertThat(uvhClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(uvhClassSubject.uniqueFieldWithName("unused_"), isPresent());
+ assertThat(uvhClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(uvhClassSubject.uniqueFieldWithOriginalName("unused_"), isPresent());
}
// Verify that various proto fields have been removed in the output.
{
ClassSubject cfofClassSubject = outputInspector.clazz(CONTAINS_FLAGGED_OFF_FIELD);
assertThat(cfofClassSubject, isPresent());
- assertThat(cfofClassSubject.uniqueFieldWithName("conditionallyUsed_"), not(isPresent()));
+ assertThat(
+ cfofClassSubject.uniqueFieldWithOriginalName("conditionallyUsed_"), not(isPresent()));
ClassSubject puClassSubject = outputInspector.clazz(PARTIALLY_USED);
assertThat(puClassSubject, isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("bitField0_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), not(isPresent()));
- assertThat(puClassSubject.uniqueFieldWithName("unusedEnum_"), not(isPresent()));
- assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedEnum_"), not(isPresent()));
- assertThat(puClassSubject.uniqueFieldWithName("unusedMessage_"), not(isPresent()));
- assertThat(puClassSubject.uniqueFieldWithName("unusedRepeatedMessage_"), not(isPresent()));
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), not(isPresent()));
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedEnum_"), not(isPresent()));
+ assertThat(
+ puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedEnum_"), not(isPresent()));
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("unusedMessage_"), not(isPresent()));
+ assertThat(
+ puClassSubject.uniqueFieldWithOriginalName("unusedRepeatedMessage_"), not(isPresent()));
ClassSubject uvhClassSubject = outputInspector.clazz(USED_VIA_HAZZER);
assertThat(uvhClassSubject, isPresent());
- assertThat(uvhClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(uvhClassSubject.uniqueFieldWithName("unused_"), not(isPresent()));
+ assertThat(uvhClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(uvhClassSubject.uniqueFieldWithOriginalName("unused_"), not(isPresent()));
}
}
@@ -316,18 +338,18 @@
{
ClassSubject classSubject = inputInspector.clazz(USES_ONLY_REPEATED_FIELDS);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("bitField0_"), isPresent());
- assertThat(classSubject.uniqueFieldWithName("myoneof_"), isPresent());
- assertThat(classSubject.uniqueFieldWithName("myoneofCase_"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("bitField0_"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("myoneof_"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("myoneofCase_"), isPresent());
}
// Verify that various proto fields have been removed in the output.
{
ClassSubject classSubject = outputInspector.clazz(USES_ONLY_REPEATED_FIELDS);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("bitField0_"), not(isPresent()));
- assertThat(classSubject.uniqueFieldWithName("myoneof_"), not(isPresent()));
- assertThat(classSubject.uniqueFieldWithName("myoneofCase_"), not(isPresent()));
+ assertThat(classSubject.uniqueFieldWithOriginalName("bitField0_"), not(isPresent()));
+ assertThat(classSubject.uniqueFieldWithOriginalName("myoneof_"), not(isPresent()));
+ assertThat(classSubject.uniqueFieldWithOriginalName("myoneofCase_"), not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
index e2b8e51..0fa0a5b 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
@@ -84,16 +84,16 @@
ClassSubject puClassSubject = inputInspector.clazz(PARTIALLY_USED);
assertThat(puClassSubject, isPresent());
assertEquals(2, puClassSubject.allInstanceFields().size());
- assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), isPresent());
}
// Verify that various proto fields have been removed in the output.
{
ClassSubject puClassSubject = outputInspector.clazz(PARTIALLY_USED);
assertThat(puClassSubject, isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("used_"), isPresent());
- assertThat(puClassSubject.uniqueFieldWithName("completelyUnused_"), not(isPresent()));
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("used_"), isPresent());
+ assertThat(puClassSubject.uniqueFieldWithOriginalName("completelyUnused_"), not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
index a015fd9..0f596b1 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
@@ -94,7 +94,8 @@
public void buildAndCheckIR(String methodName, Consumer<IRCode> irInspector) {
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
- MethodSubject methodSubject = inspector.clazz(className).uniqueMethodWithName(methodName);
+ MethodSubject methodSubject =
+ inspector.clazz(className).uniqueMethodWithOriginalName(methodName);
irInspector.accept(methodSubject.buildIR(appView));
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java b/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
index 7d05b2d..d48d5ad 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/initializedclasses/InitializedClassesOnNormalExitAnalysisTest.java
@@ -68,7 +68,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("inlineable");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("inlineable");
assertThat(methodSubject, not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
index 065e069..c74f7e5 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/ArrayOfObjectsCreationCanBePostponedTest.java
@@ -49,7 +49,7 @@
assertThat(classSubject, isPresent());
// We should have been able to inline A.inlineable() since A.<clinit>() can safely be postponed.
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
index a108b5f..2399475 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/EnumClassInitializerCanBePostponedTest.java
@@ -55,10 +55,10 @@
private void inspect(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
for (String methodName : ImmutableList.of("testIf", "testSwitch")) {
- MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
// Verify that all enum reads have been removed.
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
index eb3138c..ffce57c 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
@@ -69,7 +69,7 @@
"arrayWithIndirectFinalizer",
"otherArrayInstanceWithoutFinalizer");
for (String name : presentFields) {
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName(name);
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName(name);
assertThat(name, fieldSubject, isPresent());
assertTrue(
mainSubject
@@ -87,7 +87,7 @@
"indirectInstanceWithoutFinalizer",
"arrayWithoutFinalizer");
for (String name : absentFields) {
- assertThat(classSubject.uniqueFieldWithName(name), not(isPresent()));
+ assertThat(classSubject.uniqueFieldWithOriginalName(name), not(isPresent()));
}
})
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
index 1950e53..31c7346 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
@@ -53,7 +53,7 @@
// A.inlineable() should be inlined because we should be able to determine that A.<clinit>() can
// safely be postponed.
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
index 7bc227a..61047fe 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
@@ -49,8 +49,8 @@
assertThat(classSubject, isPresent());
// The field A.INSTANCE has been accessed to allow inlining of A.inlineable().
- assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
index 8d3cae4..abf1395 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCanBePostponedTest.java
@@ -15,7 +15,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ir.analysis.sideeffect.SingletonClassInitializerPatternCanBePostponedTest.A;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import org.junit.Test;
@@ -55,10 +54,10 @@
private void inspect(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
// A.inlineable() should be inlined, but we should not synthesize an $r8$clinit field.
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
assertEquals(2, classSubject.allStaticFields().size());
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
index 5914a59..37f49fc 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerWithInstancePutCannotBePostponedTest.java
@@ -54,10 +54,10 @@
private void inspect(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("INSTANCE"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("INSTANCE"), isPresent());
// A.inlineable() should be inlined, but we should synthesize an $r8$clinit field.
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
assertEquals(2, classSubject.allStaticFields().size());
}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
index 6573810..7db7e04 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
@@ -71,7 +71,7 @@
"testWithSwitch",
"testNullCheckIsPreserved");
for (String methodName : methodNames) {
- MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
IRCode code = methodSubject.buildIR();
List<Value> hashCodeValues =
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
index 9dcfa24..28c90bf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
@@ -190,7 +190,7 @@
int expectedThrow = hasLiveness ? 1 : 0;
for (String methodName : METHODS_WITH_NPE_GUARD) {
- MethodSubject withNPEGuard = mainClass.uniqueMethodWithName(methodName);
+ MethodSubject withNPEGuard = mainClass.uniqueMethodWithOriginalName(methodName);
assertThat(withNPEGuard, isPresent());
// catch handlers could be split, and thus not always 1, but some small positive numbers.
assertTrue(
@@ -205,12 +205,12 @@
int expectedHandler = hasLiveness ? 0 : 1;
MethodSubject withOtherGuard =
- mainClass.uniqueMethodWithName("uninstantiatedInstancePutWithOtherGuard");
+ mainClass.uniqueMethodWithOriginalName("uninstantiatedInstancePutWithOtherGuard");
assertThat(withOtherGuard, isPresent());
assertEquals(expectedHandler, Streams.stream(withOtherGuard.iterateTryCatches()).count());
for (String methodName : METHODS_WITHOUT_GUARD) {
- MethodSubject mtd = mainClass.uniqueMethodWithName(methodName);
+ MethodSubject mtd = mainClass.uniqueMethodWithOriginalName(methodName);
assertThat(mtd, isPresent());
assertEquals(
hasLiveness,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
index e582d84..c73086e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
@@ -89,24 +89,24 @@
ClassSubject mainSubject = inspector.clazz(mainClass);
assertThat(mainSubject, isPresent());
- MethodSubject selfCheck = mainSubject.uniqueMethodWithName("selfCheck");
+ MethodSubject selfCheck = mainSubject.uniqueMethodWithOriginalName("selfCheck");
assertThat(selfCheck, isPresent());
assertEquals(0, countCallToParamNullCheck(selfCheck));
assertEquals(1, countPrintCall(selfCheck));
assertEquals(0, countThrow(selfCheck));
- MethodSubject checkNull = mainSubject.uniqueMethodWithName("checkNull");
+ MethodSubject checkNull = mainSubject.uniqueMethodWithOriginalName("checkNull");
assertThat(checkNull, isPresent());
assertEquals(0, countCallToParamNullCheck(checkNull));
assertEquals(1, countPrintCall(checkNull));
assertEquals(1, countThrow(checkNull));
- MethodSubject paramCheck = mainSubject.uniqueMethodWithName("nonNullAfterParamCheck");
+ MethodSubject paramCheck = mainSubject.uniqueMethodWithOriginalName("nonNullAfterParamCheck");
assertThat(paramCheck, isPresent());
assertEquals(1, countPrintCall(paramCheck));
assertEquals(1, countThrow(paramCheck));
- paramCheck = mainSubject.uniqueMethodWithName("nonNullAfterParamCheckDifferently");
+ paramCheck = mainSubject.uniqueMethodWithOriginalName("nonNullAfterParamCheckDifferently");
assertThat(paramCheck, isPresent());
assertEquals(1, countPrintCall(paramCheck));
assertEquals(1, countThrow(paramCheck));
@@ -125,17 +125,18 @@
ClassSubject mainSubject = inspector.clazz(mainClass);
assertThat(mainSubject, isPresent());
- MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+ MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
assertThat(checkViaCall, isPresent());
assertEquals(0, countActCall(checkViaCall));
assertEquals(2, countPrintCall(checkViaCall));
- MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+ MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
assertThat(checkViaIntrinsic, isPresent());
assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
assertEquals(1, countPrintCall(checkViaIntrinsic));
- MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+ MethodSubject checkAtOneLevelHigher =
+ mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
assertThat(checkAtOneLevelHigher, isPresent());
assertEquals(1, countPrintCall(checkAtOneLevelHigher));
assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -154,17 +155,18 @@
ClassSubject mainSubject = inspector.clazz(mainClass);
assertThat(mainSubject, isPresent());
- MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+ MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
assertThat(checkViaCall, isPresent());
assertEquals(0, countActCall(checkViaCall));
assertEquals(canSharePrintCallInSuccessorBlock() ? 1 : 2, countPrintCall(checkViaCall));
- MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+ MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
assertThat(checkViaIntrinsic, isPresent());
assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
assertEquals(1, countPrintCall(checkViaIntrinsic));
- MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+ MethodSubject checkAtOneLevelHigher =
+ mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
assertThat(checkAtOneLevelHigher, isPresent());
assertEquals(1, countPrintCall(checkAtOneLevelHigher));
assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -190,17 +192,18 @@
ClassSubject mainSubject = inspector.clazz(NonNullParamAfterInvokeVirtual.class);
assertThat(mainSubject, isPresent());
- MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+ MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
assertThat(checkViaCall, isPresent());
assertEquals(0, countActCall(checkViaCall));
assertEquals(canSharePrintCallInSuccessorBlock() ? 1 : 2, countPrintCall(checkViaCall));
- MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithName("checkViaIntrinsic");
+ MethodSubject checkViaIntrinsic = mainSubject.uniqueMethodWithOriginalName("checkViaIntrinsic");
assertThat(checkViaIntrinsic, isPresent());
assertEquals(0, countCallToParamNullCheck(checkViaIntrinsic));
assertEquals(1, countPrintCall(checkViaIntrinsic));
- MethodSubject checkAtOneLevelHigher = mainSubject.uniqueMethodWithName("checkAtOneLevelHigher");
+ MethodSubject checkAtOneLevelHigher =
+ mainSubject.uniqueMethodWithOriginalName("checkAtOneLevelHigher");
assertThat(checkAtOneLevelHigher, isPresent());
assertEquals(1, countPrintCall(checkAtOneLevelHigher));
assertEquals(0, countThrow(checkAtOneLevelHigher));
@@ -246,7 +249,7 @@
ClassSubject mainSubject = inspector.clazz(NonNullParamInterfaceImpl.class);
assertThat(mainSubject, isPresent());
- MethodSubject checkViaCall = mainSubject.uniqueMethodWithName("checkViaCall");
+ MethodSubject checkViaCall = mainSubject.uniqueMethodWithOriginalName("checkViaCall");
assertThat(checkViaCall, isPresent());
assertEquals(0, countActCall(checkViaCall));
// The DEX backend reuses the System.out.println invoke.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
index f40816f..843ceef 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
@@ -89,12 +89,12 @@
assertThat(mainMethod, isPresent());
assertEquals(expectedCountInMain, countObjectsRequireNonNull(mainMethod));
- MethodSubject unknownArg = mainClass.uniqueMethodWithName("unknownArg");
+ MethodSubject unknownArg = mainClass.uniqueMethodWithOriginalName("unknownArg");
assertThat(unknownArg, isPresent());
// Due to the nullable argument, requireNonNull should remain.
assertEquals(1, countObjectsRequireNonNull(unknownArg));
- MethodSubject uninit = mainClass.uniqueMethodWithName("consumeUninitialized");
+ MethodSubject uninit = mainClass.uniqueMethodWithOriginalName("consumeUninitialized");
assertThat(uninit, isPresent());
assertEquals(expectedCountInConsumer, countObjectsRequireNonNull(uninit));
if (expectedCountInConsumer == 0) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
index 7dc327c..ae4ea81 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/OptimizationSummaryForKeptMethodTest.java
@@ -63,7 +63,8 @@
// Main method invokes noNormalExits() since it is not allowed to be inlined.
assertThat(
mainMethodSubject,
- invokesMethod(inspector.clazz(KeptClass.class).uniqueMethodWithName("noNormalExits")));
+ invokesMethod(
+ inspector.clazz(KeptClass.class).uniqueMethodWithOriginalName("noNormalExits")));
// The fact that noNormalExits() never returns normally has only been exploited if it is not
// kept.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index 303bf0c..0e02656 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -360,10 +360,10 @@
CodeInspector inspector =
new CodeInspector(ImmutableList.of(getGeneratedFile()), getGeneratedProguardMap(), null);
ClassSubject clazz = inspector.clazz(nullabilityClass);
- assertThat(clazz.uniqueMethodWithName("conditionalOperator"), isAbsent());
+ assertThat(clazz.uniqueMethodWithOriginalName("conditionalOperator"), isAbsent());
// The enum parameter is unboxed.
- MethodSubject m = clazz.uniqueMethodWithName("moreControlFlows");
+ MethodSubject m = clazz.uniqueMethodWithOriginalName("moreControlFlows");
assertTrue(m.isPresent());
// Verify that a.b() is resolved to an inline instance-get.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
index 27f097b..54fee4e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/RedundantConstNumberRemovalTest.java
@@ -71,15 +71,15 @@
.assertSuccessWithOutput(expectedOutput);
ClassSubject classSubject = result.inspector().clazz(TestClass.class);
- verifyBooleanCheckTest(classSubject.uniqueMethodWithName("booleanCheckTest"));
- verifyBooleanCheckTest(classSubject.uniqueMethodWithName("negateBooleanCheckTest"));
- verifyIntCheckTest(classSubject.uniqueMethodWithName("intCheckTest"));
- verifyIntCheckTest(classSubject.uniqueMethodWithName("negateIntCheckTest"));
- verifyNullCheckTest(classSubject.uniqueMethodWithName("nullCheckTest"));
- verifyNullCheckTest(classSubject.uniqueMethodWithName("invertedNullCheckTest"));
- verifyNullCheckTest(classSubject.uniqueMethodWithName("nonNullCheckTest"));
+ verifyBooleanCheckTest(classSubject.uniqueMethodWithOriginalName("booleanCheckTest"));
+ verifyBooleanCheckTest(classSubject.uniqueMethodWithOriginalName("negateBooleanCheckTest"));
+ verifyIntCheckTest(classSubject.uniqueMethodWithOriginalName("intCheckTest"));
+ verifyIntCheckTest(classSubject.uniqueMethodWithOriginalName("negateIntCheckTest"));
+ verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("nullCheckTest"));
+ verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("invertedNullCheckTest"));
+ verifyNullCheckTest(classSubject.uniqueMethodWithOriginalName("nonNullCheckTest"));
verifyNullCheckWithWrongTypeTest(
- classSubject.uniqueMethodWithName("nullCheckWithWrongTypeTest"));
+ classSubject.uniqueMethodWithOriginalName("nullCheckWithWrongTypeTest"));
}
private void verifyBooleanCheckTest(MethodSubject methodSubject) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
index 3d3db4a..0134f78 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/SubsumedCatchHandlerTest.java
@@ -117,6 +117,6 @@
assertEquals("java.lang.Exception", guard.toSourceString());
}
- assertThat(classSubject.uniqueMethodWithName("foo"), isAbsent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("foo"), isAbsent());
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
index 283718d..6654e42 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/CallSiteOptimizationWithInvokeCustomTargetTest.java
@@ -67,9 +67,9 @@
.inspect(
inspector -> {
ClassSubject clazz = inspector.clazz(TestClass.class);
- assertThat(clazz.uniqueMethodWithName("bootstrap"), isPresent());
- assertThat(clazz.uniqueMethodWithName("bar"), isPresent());
- assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("bootstrap"), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName("bar"), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
index e3afc1c..051b633 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
@@ -81,7 +81,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Can optimize branches since `arg` is definitely null.
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -89,7 +89,7 @@
ClassSubject bSub = inspector.clazz(BSub.class);
assertThat(bSub, isPresent());
- MethodSubject bSub_m = bSub.uniqueMethodWithName("m");
+ MethodSubject bSub_m = bSub.uniqueMethodWithOriginalName("m");
assertThat(bSub_m, isPresent());
// Can optimize branches since `arg` is definitely null.
assertTrue(bSub_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
ClassSubject c = inspector.clazz(C.class);
assertThat(c, isPresent());
- MethodSubject c_m = c.uniqueMethodWithName("m");
+ MethodSubject c_m = c.uniqueMethodWithOriginalName("m");
assertThat(c_m, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(c_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
index 847bf55..2127c35 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
@@ -76,7 +76,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Can optimize branches since `arg` is definitely null.
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -84,7 +84,7 @@
ClassSubject bSub = inspector.clazz(BSub.class);
assertThat(bSub, isPresent());
- MethodSubject bSub_m = bSub.uniqueMethodWithName("m");
+ MethodSubject bSub_m = bSub.uniqueMethodWithOriginalName("m");
assertThat(bSub_m, isPresent());
// Can optimize branches since `arg` is definitely null.
assertTrue(bSub_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -92,7 +92,7 @@
ClassSubject c = inspector.clazz(C.class);
assertThat(c, isPresent());
- MethodSubject c_m = c.uniqueMethodWithName("m");
+ MethodSubject c_m = c.uniqueMethodWithOriginalName("m");
assertThat(c_m, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(c_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
index 25f6b89..cb43b17 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/KeptMethodTest.java
@@ -61,7 +61,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject m = a.uniqueMethodWithName("m");
+ MethodSubject m = a.uniqueMethodWithOriginalName("m");
assertThat(m, isPresent());
// Should not optimize branches since the method is kept, accessed via reflection.
assertTrue(m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
index e4b5197..b0f6cc4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/LibraryMethodOverridesTest.java
@@ -76,7 +76,7 @@
ClassSubject customPredicate = inspector.clazz(CustomPredicate.class);
assertThat(customPredicate, isPresent());
- MethodSubject m = customPredicate.uniqueMethodWithName("test");
+ MethodSubject m = customPredicate.uniqueMethodWithOriginalName("test");
// Should not optimize branches since the method is overriding a library method.
assertTrue(m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
index 3dc868d..8f500e1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
@@ -59,7 +59,7 @@
// Check if the candidate is indeed staticized.
ClassSubject companion = inspector.clazz(Host.Companion.class);
assertThat(companion, isPresent());
- MethodSubject foo = companion.uniqueMethodWithName("foo");
+ MethodSubject foo = companion.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
assertThat(foo, isStatic());
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
index f55c70b..b35e0e3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
@@ -65,7 +65,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
index 2c79f4c..47682c0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
@@ -60,7 +60,7 @@
assertThat(mainMethodSubject, isPresent());
assertTrue(mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isConstString));
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
assertEquals(0, test.getProgramMethod().getReference().getArity());
// Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
index ca24f1f..8e5efc5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
@@ -73,7 +73,7 @@
assertThat(i, isPresent());
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
index d1a160a..fe2bf46 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
@@ -82,14 +82,14 @@
ClassSubject i = inspector.clazz(I.class);
assertThat(i, isPresent());
- MethodSubject i_m = i.uniqueMethodWithName("m");
+ MethodSubject i_m = i.uniqueMethodWithOriginalName("m");
assertThat(i_m, isPresent());
assertEquals(0, i_m.getProgramMethod().getReference().getArity());
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
assertEquals(0, a_m.getProgramMethod().getReference().getArity());
// Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
@@ -98,7 +98,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
assertEquals(0, b_m.getProgramMethod().getReference().getArity());
// Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
index 5c80990..861720e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
@@ -63,7 +63,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
index 9f01b31..a6b2376 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
@@ -59,7 +59,7 @@
assertTrue(
mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isConstString));
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
assertEquals(0, test.getProgramMethod().getReference().getArity());
// Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
index 51593ba..0567d5d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
@@ -79,7 +79,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -87,7 +87,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
index 1c5689d..cb0a8e3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
@@ -74,7 +74,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Can optimize branches since `arg` is definitely "nul", i.e., not containing "null".
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -82,7 +82,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the value of `arg` is unsure.
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
index 76daffe..5321514 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
@@ -65,7 +65,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
index ef373cd..ad78a71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
@@ -91,7 +91,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Can optimize branches since the type of `arg` is Sub1.
assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
index 9fe54b4..dafde62 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
@@ -73,7 +73,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
index fd6b29e..e2d2d9a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
@@ -89,7 +89,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Can optimize branches since the type of `arg` is Sub1.
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
index 2055210..d57418e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
@@ -63,7 +63,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
index 2dafd1b..fbc799b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
@@ -79,7 +79,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Can optimize branches since the type of `arg` is Sub1.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
index b419ad2..a2325c8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
@@ -77,7 +77,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -85,7 +85,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the type of `arg` is unsure.
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
index 382be79..d580a1b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
@@ -89,7 +89,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Can optimize branches since the type of `arg` is Sub1.
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -97,7 +97,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Can optimize branches since the type of `arg` is Sub1.
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
index 3a3a62d..a95bac2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
@@ -61,7 +61,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
index 11c44ad..94ba810 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
@@ -64,7 +64,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
index a80798a..485b02e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
@@ -81,7 +81,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
index b3988ee..4f34bad 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
@@ -73,7 +73,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -81,7 +81,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
index 6175434..64f0588 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
@@ -57,7 +57,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(test.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
index d181d3b..c81ec91 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
@@ -62,7 +62,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject test = main.uniqueMethodWithName("test");
+ MethodSubject test = main.uniqueMethodWithOriginalName("test");
assertThat(test, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
index 60e3dd8..3606473 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
@@ -53,14 +53,14 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
index 08bd75c..9e4b9f5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
@@ -84,7 +84,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
@@ -92,7 +92,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
index c1c88a2..ecd71d8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
@@ -79,7 +79,7 @@
ClassSubject a = inspector.clazz(A.class);
assertThat(a, isPresent());
- MethodSubject a_m = a.uniqueMethodWithName("m");
+ MethodSubject a_m = a.uniqueMethodWithOriginalName("m");
assertThat(a_m, isPresent());
// Can optimize branches since `arg` is definitely not null.
assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
@@ -87,7 +87,7 @@
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
- MethodSubject b_m = b.uniqueMethodWithName("m");
+ MethodSubject b_m = b.uniqueMethodWithOriginalName("m");
assertThat(b_m, isPresent());
// Should not optimize branches since the nullability of `arg` is unsure.
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
index 7d99b55..11a24ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/ConstClassCanonicalizationMonitorTest.java
@@ -52,7 +52,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(Main.class);
assertThat(clazz, isPresent());
- MethodSubject testSubject = clazz.uniqueMethodWithName("test");
+ MethodSubject testSubject = clazz.uniqueMethodWithOriginalName("test");
assertThat(testSubject, isPresent());
Optional<InstructionSubject> insertedMonitor =
testSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
index 709a44b..c2e5e06 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EnumCanonicalizationTest.java
@@ -54,7 +54,7 @@
ClassSubject enumSubject = inspector.clazz(MyEnum.class);
assertThat(enumSubject, isPresent());
- FieldSubject enumFieldSubject = enumSubject.uniqueFieldWithName("A");
+ FieldSubject enumFieldSubject = enumSubject.uniqueFieldWithOriginalName("A");
assertThat(enumFieldSubject, isPresent());
ClassSubject enumWithClassInitializationSideEffectsSubject =
@@ -62,7 +62,7 @@
assertThat(enumWithClassInitializationSideEffectsSubject, isPresent());
FieldSubject enumWithClassInitializationSideEffectsFieldSubject =
- enumWithClassInitializationSideEffectsSubject.uniqueFieldWithName("A");
+ enumWithClassInitializationSideEffectsSubject.uniqueFieldWithOriginalName("A");
assertThat(enumWithClassInitializationSideEffectsFieldSubject, isPresent());
MethodSubject mainMethodSubject = classSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
index bc04d7e..ff6a112 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/StringInMonitorTest.java
@@ -141,7 +141,7 @@
}
}
- MethodSubject sync = mainClass.uniqueMethodWithName("sync");
+ MethodSubject sync = mainClass.uniqueMethodWithOriginalName("sync");
assertThat(sync, isPresent());
count = Streams.stream(sync.iterateInstructions(
i -> i.isConstString("", JumboStringMode.ALLOW))).count();
@@ -169,7 +169,7 @@
}
}
- MethodSubject oom = mainClass.uniqueMethodWithName("oom");
+ MethodSubject oom = mainClass.uniqueMethodWithOriginalName("oom");
assertThat(oom, isPresent());
count = Streams.stream(oom.iterateInstructions(
i -> i.isConstString("this-string-will-not-be-loaded.", JumboStringMode.ALLOW))).count();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
index 1f7b39a..5dc2510 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastNullForTypeTest.java
@@ -55,7 +55,7 @@
codeInspector -> {
ClassSubject main = codeInspector.clazz(Main.class);
assertThat(main, isPresent());
- MethodSubject mainMethod = main.uniqueMethodWithName("main");
+ MethodSubject mainMethod = main.uniqueMethodWithOriginalName("main");
assertThat(mainMethod, isPresent());
assertEquals(
0,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
index a1577a3..659764a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
@@ -52,16 +52,16 @@
private void inspect(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
MethodSubject trivialCastMethodSubject =
- classSubject.uniqueMethodWithName("trivialCastAfterBranchPruningTest");
+ classSubject.uniqueMethodWithOriginalName("trivialCastAfterBranchPruningTest");
assertThat(trivialCastMethodSubject, isPresent());
assertTrue(
trivialCastMethodSubject.streamInstructions().noneMatch(InstructionSubject::isCheckCast));
MethodSubject branchPruningMethodSubject =
- classSubject.uniqueMethodWithName("branchPruningAfterInstanceOfOptimization");
+ classSubject.uniqueMethodWithOriginalName("branchPruningAfterInstanceOfOptimization");
assertThat(branchPruningMethodSubject, isPresent());
assertTrue(
branchPruningMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
index 2922b90..30dd4b4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinitializerdefaults/NonFinalFieldWithDefaultValueTest.java
@@ -72,7 +72,7 @@
// No instructions can read field f1 before it is assigned, and therefore, we can safely
// remove the static-put instruction and update the static value of the field.
- FieldSubject f1FieldSubject = testClassSubject.uniqueFieldWithName("f1");
+ FieldSubject f1FieldSubject = testClassSubject.uniqueFieldWithOriginalName("f1");
assertThat(f1FieldSubject, isPresent());
assertNotNull(f1FieldSubject.getField().getStaticValue());
assertTrue(f1FieldSubject.getField().getStaticValue().isDexValueInt());
@@ -80,7 +80,7 @@
// Field f3 is assigned after an instruction that could read it, and therefore, we cannot safely
// remove the static-put instruction and update the static value of the field.
- FieldSubject f3FieldSubject = testClassSubject.uniqueFieldWithName("f3");
+ FieldSubject f3FieldSubject = testClassSubject.uniqueFieldWithOriginalName("f3");
assertThat(f3FieldSubject, isPresent());
assertNotNull(f3FieldSubject.getField().getStaticValue());
assertTrue(f3FieldSubject.getField().getStaticValue().isDexValueInt());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
index 16aac95..92383ae 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
@@ -73,7 +73,7 @@
.inspector();
ClassSubject clazz = inspector.clazz(Keeper.class);
assertThat(clazz, isPresent());
- MethodSubject main = clazz.uniqueMethodWithName("main");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
assertTrue(main.streamInstructions().noneMatch(i -> i.isConstString(JumboStringMode.ALLOW)));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
index efdaea1..c0daee1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerSimplePairBuilderTest.java
@@ -82,9 +82,9 @@
assertThat(inspector.clazz(PairBuilder.class), not(isPresent()));
Set<String> expected = ImmutableSet.of(StringBuilder.class.getTypeName());
- assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder1")));
- assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder2")));
- assertEquals(expected, collectTypes(clazz.uniqueMethodWithName("testSimpleBuilder3")));
+ assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder1")));
+ assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder2")));
+ assertEquals(expected, collectTypes(clazz.uniqueMethodWithOriginalName("testSimpleBuilder3")));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
index cd28e2a..c79c42e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetDirectMonitorTest.java
@@ -53,13 +53,13 @@
assertTrue(
inspector
.clazz(TestClass.class)
- .uniqueMethodWithName("produce1")
+ .uniqueMethodWithOriginalName("produce1")
.streamInstructions()
.anyMatch(InstructionSubject::isMonitorEnter));
assertTrue(
inspector
.clazz(TestClass.class)
- .uniqueMethodWithName("produce2")
+ .uniqueMethodWithOriginalName("produce2")
.streamInstructions()
.anyMatch(InstructionSubject::isMonitorExit));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
index 23c364e..a730b8a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetExtraMethodMonitorTest.java
@@ -49,7 +49,8 @@
}
private void inspect(CodeInspector inspector) {
- assertThat(inspector.clazz(Container.class).uniqueMethodWithName("increment"), isPresent());
+ assertThat(
+ inspector.clazz(Container.class).uniqueMethodWithOriginalName("increment"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
index f858a0e..32be199 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerStaticGetMonitorTest.java
@@ -49,7 +49,8 @@
}
private void inspect(CodeInspector inspector) {
- assertThat(inspector.clazz(Container.class).uniqueMethodWithName("increment"), isPresent());
+ assertThat(
+ inspector.clazz(Container.class).uniqueMethodWithOriginalName("increment"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index 8e5d660..6c30034 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -109,50 +109,52 @@
assertEquals(
Collections.singleton("java.lang.StringBuilder"),
- collectTypes(clazz.uniqueMethodWithName("testInner")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testInner")));
assertEquals(
Collections.emptySet(),
- collectTypes(clazz.uniqueMethodWithName("testConstructorMapping1")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping1")));
assertEquals(
Collections.emptySet(),
- collectTypes(clazz.uniqueMethodWithName("testConstructorMapping2")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping2")));
assertEquals(
Collections.singleton("java.lang.StringBuilder"),
- collectTypes(clazz.uniqueMethodWithName("testConstructorMapping3")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testConstructorMapping3")));
assertEquals(
- Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testEmptyClass")));
+ Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("testEmptyClass")));
assertEquals(
Collections.singleton(
"com.android.tools.r8.ir.optimize.classinliner.trivial.EmptyClassWithInitializer"),
- collectTypes(clazz.uniqueMethodWithName("testEmptyClassWithInitializer")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testEmptyClassWithInitializer")));
assertEquals(
Collections.singleton(
"com.android.tools.r8.ir.optimize.classinliner.trivial.ClassWithFinal"),
- collectTypes(clazz.uniqueMethodWithName("testClassWithFinalizer")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testClassWithFinalizer")));
assertEquals(
- Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testCallOnIface1")));
+ Collections.emptySet(),
+ collectTypes(clazz.uniqueMethodWithOriginalName("testCallOnIface1")));
assertEquals(
- Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("testCallOnIface2")));
+ Collections.emptySet(),
+ collectTypes(clazz.uniqueMethodWithOriginalName("testCallOnIface2")));
assertEquals(
Sets.newHashSet(
"com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceAB",
"java.lang.StringBuilder"),
- collectTypes(clazz.uniqueMethodWithName("testCycles")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testCycles")));
assertEquals(
Sets.newHashSet(
"java.lang.StringBuilder",
"com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceAB"),
- collectTypes(inspector.clazz(CycleReferenceAB.class).uniqueMethodWithName("foo")));
+ collectTypes(inspector.clazz(CycleReferenceAB.class).uniqueMethodWithOriginalName("foo")));
assertThat(inspector.clazz(CycleReferenceBA.class), isAbsent());
}
@@ -219,11 +221,14 @@
CodeInspector inspector = result.inspector();
ClassSubject clazz = inspector.clazz(C.class);
- assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method1")));
+ assertEquals(
+ Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method1")));
- assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method2")));
+ assertEquals(
+ Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method2")));
- assertEquals(Collections.emptySet(), collectTypes(clazz.uniqueMethodWithName("method3")));
+ assertEquals(
+ Collections.emptySet(), collectTypes(clazz.uniqueMethodWithOriginalName("method3")));
assertFalse(inspector.clazz(C.L.class).isPresent());
assertFalse(inspector.clazz(C.F.class).isPresent());
@@ -264,15 +269,15 @@
// TODO(b/143129517, 141719453): This expectation relies on the class inlining limits.
assertEquals(
Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
- collectTypes(clazz.uniqueMethodWithName("testExtraNeverReturnsNormally")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testExtraNeverReturnsNormally")));
assertEquals(
Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
- collectTypes(clazz.uniqueMethodWithName("testDirectNeverReturnsNormally")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testDirectNeverReturnsNormally")));
assertEquals(
Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
- collectTypes(clazz.uniqueMethodWithName("testInitNeverReturnsNormally")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testInitNeverReturnsNormally")));
assertThat(
inspector.clazz(InvalidRootsTestClass.NeverReturnsNormally.class),
@@ -283,7 +288,7 @@
// TODO(b/143129517, b/141719453): This expectation relies on the class inlining limits.
assertEquals(
Sets.newHashSet("java.lang.StringBuilder", "java.lang.RuntimeException"),
- collectTypes(clazz.uniqueMethodWithName("testRootInvalidatesAfterInlining")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testRootInvalidatesAfterInlining")));
assertThat(inspector.clazz(InvalidRootsTestClass.A.class), not(isPresent()));
assertThat(inspector.clazz(InvalidRootsTestClass.B.class), not(isPresent()));
@@ -323,13 +328,13 @@
// TODO(b/120814598): Should only be "java.lang.StringBuilder".
assertEquals(
new HashSet<>(synthesizedJavaLambdaClasses),
- collectTypes(clazz.uniqueMethodWithName("testStatelessLambda")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testStatelessLambda")));
assertTrue(
inspector.allClasses().stream().anyMatch(ClassSubject::isSynthesizedJavaLambdaClass));
assertEquals(
Sets.newHashSet("java.lang.StringBuilder"),
- collectTypes(clazz.uniqueMethodWithName("testStatefulLambda")));
+ collectTypes(clazz.uniqueMethodWithOriginalName("testStatefulLambda")));
}
private String getProguardConfig(String main) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
index 6fe9d09..809c81a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classmerger/vertical/NoLongerSyntheticAfterVerticalClassMergingTest.java
@@ -57,7 +57,7 @@
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithName("m");
+ MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithOriginalName("m");
assertThat(mMethodSubject, isPresent());
assertFalse(mMethodSubject.getMethod().accessFlags.isSynthetic());
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
index e82bd6e..f3d1079 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizeLibrarySuperTest.java
@@ -46,7 +46,8 @@
.compile()
.inspect(
inspector -> {
- MethodSubject fooMethod = inspector.clazz(Main.class).uniqueMethodWithName("foo");
+ MethodSubject fooMethod =
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
assertThat(fooMethod, isPresent());
assertThat(
fooMethod,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
index 2b6a5c8..bb751a2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTestRunner.java
@@ -52,7 +52,7 @@
CodeInspector inspector = result.inspector();
ClassSubject mainSubject = inspector.clazz(MAIN);
assertThat(mainSubject, isPresent());
- MethodSubject methodSubject = mainSubject.uniqueMethodWithName("booRunner");
+ MethodSubject methodSubject = mainSubject.uniqueMethodWithOriginalName("booRunner");
assertThat(methodSubject, isPresent());
verifyNotDevirtualized(methodSubject);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
index e4b2d91..82e963b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
@@ -60,14 +60,14 @@
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject negativeTestSubject = bClassSubject.uniqueMethodWithName("negativeTest");
+ MethodSubject negativeTestSubject = bClassSubject.uniqueMethodWithOriginalName("negativeTest");
assertThat(negativeTestSubject, isPresent());
assertTrue(negativeTestSubject.streamInstructions().anyMatch(this::isInvokeSuper));
assertTrue(
negativeTestSubject.streamInstructions().noneMatch(InstructionSubject::isInvokeVirtual));
// B.positiveTest() is moved to A as a result of bridge hoisting.
- MethodSubject positiveTestSubject = aClassSubject.uniqueMethodWithName("positiveTest");
+ MethodSubject positiveTestSubject = aClassSubject.uniqueMethodWithOriginalName("positiveTest");
assertThat(positiveTestSubject, isPresent());
assertTrue(positiveTestSubject.streamInstructions().noneMatch(this::isInvokeSuper));
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
index 6570849..a0bbdb1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/PrivateOverridePublicizerDevirtualizerTest.java
@@ -60,7 +60,7 @@
inspector -> {
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject fooA = classA.uniqueMethodWithName("foo");
+ MethodSubject fooA = classA.uniqueMethodWithOriginalName("foo");
assertThat(fooA, isPresent());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
index ca2d49a..daed986 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
@@ -66,7 +66,7 @@
// Verify that the check-cast instruction is still present in testCheckCastRemoval().
MethodSubject testCheckCastRemovalMethod =
- mainClassSubject.uniqueMethodWithName("testCheckCastRemoval");
+ mainClassSubject.uniqueMethodWithOriginalName("testCheckCastRemoval");
assertThat(testCheckCastRemovalMethod, isPresent());
assertTrue(
testCheckCastRemovalMethod
@@ -76,7 +76,7 @@
// Verify that the instance-of instruction is only present in testInstanceOfRemoval() if the
// dynamic type optimization is disabled.
MethodSubject testInstanceOfRemovalMethod =
- mainClassSubject.uniqueMethodWithName("testInstanceOfRemoval");
+ mainClassSubject.uniqueMethodWithOriginalName("testInstanceOfRemoval");
assertThat(testInstanceOfRemovalMethod, isPresent());
assertTrue(
testInstanceOfRemovalMethod
@@ -86,18 +86,18 @@
// Verify that world() has been inlined() into testMethodInlining() unless the dynamic type
// optimization is disabled.
MethodSubject testMethodInliningMethod =
- mainClassSubject.uniqueMethodWithName("testMethodInlining");
+ mainClassSubject.uniqueMethodWithOriginalName("testMethodInlining");
assertThat(testMethodInliningMethod, isPresent());
- assertTrue(interfaceSubject.uniqueMethodWithName("world").isAbsent());
+ assertTrue(interfaceSubject.uniqueMethodWithOriginalName("world").isAbsent());
// Verify that exclamationMark() has been rebound in testMethodRebinding() unless the dynamic
// type optimization is disabled.
MethodSubject testMethodRebindingMethod =
- mainClassSubject.uniqueMethodWithName("testMethodRebinding");
+ mainClassSubject.uniqueMethodWithOriginalName("testMethodRebinding");
assertThat(testMethodRebindingMethod, isPresent());
assertThat(
testMethodRebindingMethod,
- invokesMethod(aClassSubject.uniqueMethodWithName("exclamationMark")));
+ invokesMethod(aClassSubject.uniqueMethodWithOriginalName("exclamationMark")));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
index 65cc34d..03c69b1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/AbstractClassAlsoImplementedByMissingClassTest.java
@@ -67,15 +67,15 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject.uniqueMethodWithName("kept"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
- assertThat(bClassSubject.uniqueMethodWithName("kept"), isPresent());
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
// A.notKept() and B.notKept() should not be present, because the only invoke instruction
// targeting A.notKept() should have been inlined.
- assertThat(aClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
index 89586d8..c073c8b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/extrasubclasses/InterfaceAlsoImplementedByMissingClassTest.java
@@ -65,15 +65,15 @@
private void inspect(CodeInspector inspector) {
ClassSubject iClassSubject = inspector.clazz(I.class);
- assertThat(iClassSubject.uniqueMethodWithName("kept"), isPresent());
+ assertThat(iClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject.uniqueMethodWithName("kept"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("kept"), isPresent());
// I.notKept() and A.notKept() should not be present, because the only invoke instruction
// targeting I.notKept() should have been inlined.
- assertThat(iClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
- assertThat(aClassSubject.uniqueMethodWithName("notKept"), not(isPresent()));
+ assertThat(iClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("notKept"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
index 53a83d5..4b60883 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/IfThrowNullPointerExceptionTest.java
@@ -90,7 +90,7 @@
String methodName,
boolean isNPEWithMessage,
boolean shouldBeOptimized) {
- MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
IRCode code = methodSubject.buildIR();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
index a8bccea..1225b7f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/SemiTrivialPhiBranchTest.java
@@ -50,8 +50,8 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
assertThat(testClassSubject.mainMethod(), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
index 5e5f50c..3d520ac 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/TrivialObjectEqualsTest.java
@@ -42,7 +42,7 @@
.inspect(
inspector ->
assertThat(
- inspector.clazz(Main.class).uniqueMethodWithName("dead"),
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("dead"),
not(invokesMethodWithName("dead"))))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Hello world!");
@@ -58,7 +58,8 @@
.compile()
.inspect(
inspector ->
- assertThat(inspector.clazz(Main.class).uniqueMethodWithName("dead"), isAbsent()))
+ assertThat(
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("dead"), isAbsent()))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Hello world!");
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
index 527d320..94c8213 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
@@ -84,7 +84,7 @@
assertThat(otherClassSubject, isPresent());
// Method A.m() should no longer be present due to inlining.
- assertThat(otherClassSubject.uniqueMethodWithName("m"), not(isPresent()));
+ assertThat(otherClassSubject.uniqueMethodWithOriginalName("m"), not(isPresent()));
}
private boolean canUseRequireNonNull() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
index 634d0a8..2dee8a7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineLibraryInterfaceMethodTest.java
@@ -52,7 +52,10 @@
.inspect(
inspector -> {
MethodSubject methodSubject =
- inspector.clazz(TestClass.class).uniqueMethodWithName("main").asMethodSubject();
+ inspector
+ .clazz(TestClass.class)
+ .uniqueMethodWithOriginalName("main")
+ .asMethodSubject();
counts.run = countInvokesWithName(methodSubject, "run");
counts.println = countInvokesWithName(methodSubject, "println");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
index 53fa602..ed2f50d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMethodWithRetargetedLibMemberTest.java
@@ -55,7 +55,7 @@
.inspect(
inspector ->
assertThat(
- inspector.clazz(TestClass.class).uniqueMethodWithName("test"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("test"),
not(isPresent())));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
index b2fe085..e4ad5b8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
@@ -38,11 +38,11 @@
// Verify that greet() is not inlined into main() -- that would lead to illegal access errors
// since main() does not have access to the GreetingBase.greeting field.
- assertThat(greeterSubject.uniqueMethodWithName("greet"), isPresent());
+ assertThat(greeterSubject.uniqueMethodWithOriginalName("greet"), isPresent());
// The method greetInternal() should be inlined into greet() since it has a single call site and
// nothing prevents it from being inlined.
- assertThat(greeterSubject.uniqueMethodWithName("greetInternal"), not(isPresent()));
+ assertThat(greeterSubject.uniqueMethodWithOriginalName("greetInternal"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
index 45997a8..d2e9063 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedMethodTest.java
@@ -46,7 +46,7 @@
2,
inspector
.clazz(TestClass.class)
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.filter(i -> i.isMonitorEnter() || i.isMonitorExit())
.count());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
index 1cb4d4f..7fd5b34 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineSynchronizedTest.java
@@ -71,7 +71,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
assertThat(
- aClassSubject.uniqueMethodWithName("normalInlinedSynchronized"),
+ aClassSubject.uniqueMethodWithOriginalName("normalInlinedSynchronized"),
not(isPresent()));
ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
index be2ffe2..960e3d9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
@@ -69,7 +69,7 @@
assertTrue(
inspector
.clazz(Main.class)
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
index db81629..b9a6aa4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
@@ -61,13 +61,15 @@
ClassSubject mainClassSubject = inspector.clazz(ExceptionHandlingTestClass.class);
assertThat(mainClassSubject, isPresent());
assertThat(
- mainClassSubject.uniqueMethodWithName("inlineeWithNormalExitThatDoesNotThrow"),
+ mainClassSubject.uniqueMethodWithOriginalName(
+ "inlineeWithNormalExitThatDoesNotThrow"),
isAbsent());
assertThat(
- mainClassSubject.uniqueMethodWithName("inlineeWithNormalExitThatThrows"),
+ mainClassSubject.uniqueMethodWithOriginalName("inlineeWithNormalExitThatThrows"),
isAbsent());
assertThat(
- mainClassSubject.uniqueMethodWithName("inlineeWithoutNormalExit"), isAbsent());
+ mainClassSubject.uniqueMethodWithOriginalName("inlineeWithoutNormalExit"),
+ isAbsent());
})
.run(ExceptionHandlingTestClass.class)
.assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
index b4c0a63..c93ceea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
@@ -51,10 +51,10 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
- MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
assertThat(notInlineableMethod, isPresent());
MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -73,7 +73,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
@@ -86,7 +86,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
@@ -101,7 +101,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
@@ -114,7 +114,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
@@ -127,10 +127,10 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
assertThat(notInlineableMethod, isPresent());
- MethodSubject testMethod = inspector.clazz(mainClass).uniqueMethodWithName("test");
+ MethodSubject testMethod = inspector.clazz(mainClass).uniqueMethodWithOriginalName("test");
assertThat(testMethod, isPresent());
assertThat(testMethod, invokesMethod(notInlineableMethod));
}
@@ -150,7 +150,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
@@ -166,10 +166,11 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
assertThat(notInlineableMethod, isPresent());
- MethodSubject alsoNotInlineableMethod = classA.uniqueMethodWithName("alsoNotInlineable");
+ MethodSubject alsoNotInlineableMethod =
+ classA.uniqueMethodWithOriginalName("alsoNotInlineable");
assertThat(alsoNotInlineableMethod, isPresent());
MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -189,7 +190,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithOriginalName("notInlineable");
assertThat(notInlineableMethod, isPresent());
MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
@@ -206,7 +207,7 @@
ClassSubject classA = inspector.clazz(A.class);
assertThat(classA, isPresent());
- MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classA.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
index f70aebe..448a7b7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
@@ -69,19 +69,19 @@
ClassSubject classC = inspector.clazz(C.class);
assertThat(classC, isPresent());
- MethodSubject testMethod = classB.uniqueMethodWithName("test");
+ MethodSubject testMethod = classB.uniqueMethodWithOriginalName("test");
assertThat(testMethod, isPresent());
- MethodSubject inlineable1Method = classA.uniqueMethodWithName("inlineable1");
+ MethodSubject inlineable1Method = classA.uniqueMethodWithOriginalName("inlineable1");
assertThat(inlineable1Method, not(isPresent()));
- MethodSubject inlineable2Method = classB.uniqueMethodWithName("inlineable2");
+ MethodSubject inlineable2Method = classB.uniqueMethodWithOriginalName("inlineable2");
assertThat(inlineable2Method, not(isPresent()));
MethodSubject inlineableWithInitClassMethod =
- classC.uniqueMethodWithName("inlineableWithInitClass");
+ classC.uniqueMethodWithOriginalName("inlineableWithInitClass");
assertThat(inlineableWithInitClassMethod, not(isPresent()));
- assertThat(testMethod, accessesField(classC.uniqueFieldWithName("$r8$clinit")));
+ assertThat(testMethod, accessesField(classC.uniqueFieldWithOriginalName("$r8$clinit")));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
index 841c369..19806fb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningIntoVisibilityBridgeTest.java
@@ -68,7 +68,7 @@
ClassSubject classSubject = result.inspector().clazz(getClassA());
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("method");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("method");
assertEquals(neverInline, methodSubject.isPresent());
}
@@ -79,7 +79,7 @@
result.inspector().clazz(InliningIntoVisibilityBridgeTestClassB.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("method");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("method");
if (!neverInline) {
assertThat(methodSubject, isPresentAndRenamed());
assertFalse(methodSubject.isBridge());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
index cc347c5..2350b12 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
@@ -51,9 +51,9 @@
private void verifyOutput(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("foo"), not(isPresent()));
- assertThat(classSubject.uniqueMethodWithName("bar"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("baz"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("bar"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("baz"), isPresent());
}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
index ab412be..4694c08 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
@@ -42,10 +42,10 @@
ClassSubject classB = inspector.clazz(B.class);
assertThat(classB, isPresent());
- MethodSubject inlineableMethod = classB.uniqueMethodWithName("inlineable");
+ MethodSubject inlineableMethod = classB.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineableMethod, not(isPresent()));
- MethodSubject otherMethod = classB.uniqueMethodWithName("other");
+ MethodSubject otherMethod = classB.uniqueMethodWithOriginalName("other");
assertThat(otherMethod, isPresent());
MethodSubject mainMethod = inspector.clazz(TestClass.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
index 3882a7b..dea2a26 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/LibraryOverrideInliningTest.java
@@ -47,7 +47,7 @@
assertThat(greeterClassSubject, isPresent());
MethodSubject toStringMethodSubject =
- greeterClassSubject.uniqueMethodWithName("toString");
+ greeterClassSubject.uniqueMethodWithOriginalName("toString");
assertThat(toStringMethodSubject, isPresent());
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
index 09bb71b..09f4c9b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/MultipleIndirectCallSitesTest.java
@@ -71,7 +71,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("m");
+ MethodSubject methodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
assertThat(methodSubject, isPresent());
assertEquals(
5,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
index e0a1d16..9fae6b0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
@@ -65,16 +65,16 @@
assertThat(testClassSubject, isPresent());
// The indirection() method should be inlined.
- assertThat(testClassSubject.uniqueMethodWithName("indirection"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("indirection"), not(isPresent()));
// A.foo() should be absent if the max inlining depth is 1, because indirection() has been
// inlined into main(), which makes A.foo() eligible for inlining into main().
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("foo"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
// A.bar() should always be inlined because it is marked as @AlwaysInline.
- assertThat(aClassSubject.uniqueMethodWithName("bar"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("bar"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
index e7b6931..4dcba65 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetFromExactReceiverTypeTest.java
@@ -68,19 +68,25 @@
private void verifyOnlyCanBeInlinedHasBeenInlined(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("canBeInlined"), not(isPresent()));
- assertThat(aClassSubject.uniqueMethodWithName("canBeInlinedDueToAssume"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("canBeInlined"), not(isPresent()));
assertThat(
- aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule"), isPresent());
+ aClassSubject.uniqueMethodWithOriginalName("canBeInlinedDueToAssume"), not(isPresent()));
+ assertThat(
+ aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch"),
+ isPresent());
+ assertThat(
+ aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule"), isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("canBeInlined"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("canBeInlinedDueToAssume"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("canBeInlined"), not(isPresent()));
assertThat(
- bClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch"), isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule"), isPresent());
+ bClassSubject.uniqueMethodWithOriginalName("canBeInlinedDueToAssume"), not(isPresent()));
+ assertThat(
+ bClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch"),
+ isPresent());
+ assertThat(
+ bClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule"), isPresent());
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
@@ -100,10 +106,11 @@
}
assertThat(
mainMethodSubject,
- invokesMethod(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToDynamicDispatch")));
+ invokesMethod(
+ aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToDynamicDispatch")));
assertThat(
mainMethodSubject,
- invokesMethod(aClassSubject.uniqueMethodWithName("cannotBeInlinedDueToKeepRule")));
+ invokesMethod(aClassSubject.uniqueMethodWithOriginalName("cannotBeInlinedDueToKeepRule")));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
index c55ea29..96f9184 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/NopInliningConstraintTest.java
@@ -50,11 +50,11 @@
assertThat(mainClassSubject, isPresent());
// Method doStuff() is inlined into main().
- assertThat(mainClassSubject.uniqueMethodWithName("doStuff"), isAbsent());
+ assertThat(mainClassSubject.uniqueMethodWithOriginalName("doStuff"), isAbsent());
// Method checkNotNull() is not inlined.
MethodSubject checkNotNullMethodSubject =
- mainClassSubject.uniqueMethodWithName("checkNotNull");
+ mainClassSubject.uniqueMethodWithOriginalName("checkNotNull");
assertThat(checkNotNullMethodSubject, isPresent());
// There is a single call to checkNotNull() in main(), as checkNotNull(newObject())
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
index f75c4c8..685036d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfNullOrNotNullInliningTest.java
@@ -80,10 +80,10 @@
}
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfNullTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfBothNullTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfNotNullTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfBothNotNullTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfNullTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothNullTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfNotNullTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothNotNullTest"), isPresent());
}
private boolean shouldBeEligibleForSimpleInlining() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
index 180b971..18804c7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SimpleIfTrueOrFalseInliningTest.java
@@ -80,10 +80,10 @@
}
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfTrueTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfBothTrueTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfFalseTest"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("simpleIfBothFalseTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfTrueTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothTrueTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfFalseTest"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("simpleIfBothFalseTest"), isPresent());
}
private boolean shouldBeEligibleForSimpleInlining() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
index 8a606a7..1a20851 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlineStaticSynchronizedMethodTest.java
@@ -53,8 +53,8 @@
private void verifySynchronizedMethodsAreInlined(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(RunnableImpl.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("m1"), not(isPresent()));
- assertThat(classSubject.uniqueMethodWithName("m2"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
index 6ac9e07..d6c07ca 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/sync/InlinerMonitorEnterValuesThresholdTest.java
@@ -54,13 +54,13 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
assertThat(classSubject.mainMethod(), isPresent());
- assertThat(classSubject.uniqueMethodWithName("m1"), not(isPresent()));
- assertThat(classSubject.uniqueMethodWithName("m2"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
if (threshold == 2) {
- assertThat(classSubject.uniqueMethodWithName("m3"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("m3"), isPresent());
} else {
assert threshold == 3;
- assertThat(classSubject.uniqueMethodWithName("m3"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("m3"), not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
index 09aef4c..aa2e06a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/InstanceOfRemovalTest.java
@@ -167,14 +167,14 @@
ClassSubject testClass = inspector.clazz(TestClass.class);
// With inlining we can prove that all instance-of checks succeed or fail.
- MethodSubject fooMethodSubject = testClass.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = testClass.uniqueMethodWithOriginalName("foo");
Iterator<InstructionSubject> fooInstructionIterator =
fooMethodSubject.iterateInstructions(InstructionSubject::isInstanceOf);
assertEquals(0, Streams.stream(fooInstructionIterator).count());
// Without inlining we cannot prove any of the instance-of checks to be trivial, but the dynamic
// type optimization allows us to prove that some are safe.
- MethodSubject barMethodSubject = testClass.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = testClass.uniqueMethodWithOriginalName("bar");
Iterator<InstructionSubject> barInstructionIterator =
barMethodSubject.iterateInstructions(InstructionSubject::isInstanceOf);
assertEquals(2, Streams.stream(barInstructionIterator).count());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
index b6ca59d..35eb0d0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
@@ -56,7 +56,7 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- MethodSubject testClassMethodSubject = classSubject.uniqueMethodWithName("testClass");
+ MethodSubject testClassMethodSubject = classSubject.uniqueMethodWithOriginalName("testClass");
assertThat(testClassMethodSubject, isPresent());
assertTrue(
testClassMethodSubject
@@ -70,7 +70,7 @@
instruction.isInvokeVirtual()
&& instruction.getMethod().toSourceString().contains("println")));
- MethodSubject testLambdaMethodSubject = classSubject.uniqueMethodWithName("testLambda");
+ MethodSubject testLambdaMethodSubject = classSubject.uniqueMethodWithOriginalName("testLambda");
assertThat(testLambdaMethodSubject, isPresent());
assertTrue(
testLambdaMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
index 24894bb..400e662 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanParseBooleanTest.java
@@ -68,7 +68,7 @@
assertThat(testClassSubject, isPresent());
MethodSubject testOptimizedMethodSubject =
- testClassSubject.uniqueMethodWithName("testOptimized");
+ testClassSubject.uniqueMethodWithOriginalName("testOptimized");
assertThat(testOptimizedMethodSubject, isPresent());
assertTrue(
testOptimizedMethodSubject
@@ -79,7 +79,7 @@
.noneMatch(method -> method.contains("parseBoolean")));
MethodSubject testNotOptimizedMethodSubject =
- testClassSubject.uniqueMethodWithName("testNotOptimized");
+ testClassSubject.uniqueMethodWithOriginalName("testNotOptimized");
assertThat(testNotOptimizedMethodSubject, isPresent());
assertEquals(
1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
index 85eb82b..a260221 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/BooleanValueOfTest.java
@@ -53,7 +53,7 @@
assertThat(testClassSubject, isPresent());
MethodSubject testBooleanValueOfTrue =
- testClassSubject.uniqueMethodWithName("testBooleanValueOfTrue");
+ testClassSubject.uniqueMethodWithOriginalName("testBooleanValueOfTrue");
assertThat(testBooleanValueOfTrue, isPresent());
assertTrue(
testBooleanValueOfTrue
@@ -69,7 +69,7 @@
.noneMatch("TRUE"::equals));
MethodSubject testBooleanValueOfFalse =
- testClassSubject.uniqueMethodWithName("testBooleanValueOfFalse");
+ testClassSubject.uniqueMethodWithOriginalName("testBooleanValueOfFalse");
assertThat(testBooleanValueOfFalse, isPresent());
assertTrue(
testBooleanValueOfFalse
@@ -85,7 +85,7 @@
.noneMatch("FALSE"::equals));
MethodSubject testRoundTripTrueMethodSubject =
- testClassSubject.uniqueMethodWithName("testRoundTripTrue");
+ testClassSubject.uniqueMethodWithOriginalName("testRoundTripTrue");
assertThat(testRoundTripTrueMethodSubject, isPresent());
assertTrue(
testRoundTripTrueMethodSubject
@@ -95,7 +95,7 @@
.noneMatch(or("booleanValue"::equals, "valueOf"::equals)));
MethodSubject testRoundTripFalseMethodSubject =
- testClassSubject.uniqueMethodWithName("testRoundTripFalse");
+ testClassSubject.uniqueMethodWithOriginalName("testRoundTripFalse");
assertThat(testRoundTripFalseMethodSubject, isPresent());
assertTrue(
testRoundTripFalseMethodSubject
@@ -104,7 +104,8 @@
.map(invoke -> invoke.getMethod().name.toSourceString())
.noneMatch(or("booleanValue"::equals, "valueOf"::equals)));
- MethodSubject testValueOfTrue = testClassSubject.uniqueMethodWithName("testValueOfTrue");
+ MethodSubject testValueOfTrue =
+ testClassSubject.uniqueMethodWithOriginalName("testValueOfTrue");
assertThat(testValueOfTrue, isPresent());
assertTrue(
testValueOfTrue
@@ -119,7 +120,8 @@
.map(staticGet -> staticGet.getField().name.toSourceString())
.anyMatch("TRUE"::equals));
- MethodSubject testValueOfFalse = testClassSubject.uniqueMethodWithName("testValueOfFalse");
+ MethodSubject testValueOfFalse =
+ testClassSubject.uniqueMethodWithOriginalName("testValueOfFalse");
assertThat(testValueOfFalse, isPresent());
assertTrue(
testValueOfFalse
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
index 109c991..6e09e0c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
@@ -55,7 +55,7 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentsMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArguments");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArguments");
assertThat(testNonNullArgumentsMethodSubject, isPresent());
assertThat(
testNonNullArgumentsMethodSubject,
@@ -65,19 +65,19 @@
invokesMethodWithHolderAndName("java.lang.Object", "equals"));
MethodSubject testNullAndNullArgumentsMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullAndNullArguments");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullAndNullArguments");
assertThat(testNullAndNullArgumentsMethodSubject, isPresent());
assertThat(
testNullAndNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
MethodSubject testNullAndNonNullArgumentsMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullAndNonNullArguments");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullAndNonNullArguments");
assertThat(testNullAndNonNullArgumentsMethodSubject, isPresent());
assertThat(
testNullAndNonNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
MethodSubject testNullAndMaybeNullArgumentsMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullAndMaybeNullArguments");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullAndMaybeNullArguments");
assertThat(testNullAndMaybeNullArgumentsMethodSubject, isPresent());
assertThat(
testNullAndMaybeNullArgumentsMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
index 8ed1eac..680be9d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
@@ -51,14 +51,14 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(
testNonNullArgumentMethodSubject,
not(invokesMethodWithHolderAndName("java.util.Objects", "hashCode")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("hashCode")));
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
index 6064fec..9053ad5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
@@ -48,12 +48,12 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
index d4b4d35..e1b3b14 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
@@ -48,12 +48,12 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
index aadd5dd..a2391f0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
@@ -64,14 +64,14 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(
testNonNullArgumentMethodSubject,
not(invokesMethodWithName("requireNonNullElseGet")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(
testNullArgumentMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
index bde8237..7b4ed4b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
@@ -59,14 +59,14 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(
testNonNullArgumentMethodSubject,
not(invokesMethodWithName("requireNonNullElse")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(
testNullArgumentMethodSubject, not(invokesMethodWithName("requireNonNullElse")));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
index fe974a5..aed86f3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
@@ -53,12 +53,12 @@
assertThat(mainClassSubject, isPresent());
MethodSubject testNonNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNonNullArgument");
assertThat(testNonNullArgumentMethodSubject, isPresent());
assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
MethodSubject testNullArgumentMethodSubject =
- mainClassSubject.uniqueMethodWithName("testNullArgument");
+ mainClassSubject.uniqueMethodWithOriginalName("testNullArgument");
assertThat(testNullArgumentMethodSubject, isPresent());
assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
index 5dc83d0..9d6fe46 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
@@ -48,8 +48,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
index edd2219..acb9b0b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
@@ -58,11 +58,12 @@
ClassSubject configClassSubject = inspector.clazz(Config.class);
assertThat(configClassSubject, isPresent());
- FieldSubject alwaysTrueFieldSubject = configClassSubject.uniqueFieldWithName("alwaysTrue");
+ FieldSubject alwaysTrueFieldSubject =
+ configClassSubject.uniqueFieldWithOriginalName("alwaysTrue");
assertThat(alwaysTrueFieldSubject, isAbsent());
FieldSubject alwaysTrueNoSideEffectsFieldSubject =
- configClassSubject.uniqueFieldWithName("alwaysTrueNoSideEffects");
+ configClassSubject.uniqueFieldWithOriginalName("alwaysTrueNoSideEffects");
assertThat(alwaysTrueNoSideEffectsFieldSubject, not(isPresent()));
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
index b171525..7c521aa 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B135918413.java
@@ -57,11 +57,12 @@
ClassSubject configClassSubject = inspector.clazz(Config.class);
assertThat(configClassSubject, isPresent());
- FieldSubject alwaysEmptyFieldSubject = configClassSubject.uniqueFieldWithName("alwaysEmpty");
+ FieldSubject alwaysEmptyFieldSubject =
+ configClassSubject.uniqueFieldWithOriginalName("alwaysEmpty");
assertThat(alwaysEmptyFieldSubject, isPresent());
FieldSubject alwaysNonEmptyFieldSubject =
- configClassSubject.uniqueFieldWithName("alwaysNonEmpty");
+ configClassSubject.uniqueFieldWithOriginalName("alwaysNonEmpty");
assertThat(alwaysNonEmptyFieldSubject, isPresent());
MethodSubject mainMethodSubject = classSubject.mainMethod();
@@ -78,7 +79,7 @@
|| name.equals(alwaysNonEmptyFieldSubject.getFinalName())
|| name.equals("out")));
- MethodSubject deadMethodSubject = classSubject.uniqueMethodWithName("dead");
+ MethodSubject deadMethodSubject = classSubject.uniqueMethodWithOriginalName("dead");
assertThat(deadMethodSubject, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
index bef3707..8ae967b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B137041585.java
@@ -41,8 +41,11 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(R.font.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("roboto_mono_bold"), not(isPresent()));
- assertThat(classSubject.uniqueFieldWithName("roboto_mono_regular"), not(isPresent()));
+ assertThat(
+ classSubject.uniqueFieldWithOriginalName("roboto_mono_bold"), not(isPresent()));
+ assertThat(
+ classSubject.uniqueFieldWithOriginalName("roboto_mono_regular"),
+ not(isPresent()));
})
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines("1", "2", "1", "2", "1");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
index af4af19..d44418c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/ConstClassMemberValuePropagationTest.java
@@ -53,9 +53,11 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
assertThat(
- testClassSubject.uniqueMethodWithName("deadDueToFieldValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("deadDueToFieldValuePropagation"),
+ not(isPresent()));
assertThat(
- testClassSubject.uniqueMethodWithName("deadDueToReturnValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("deadDueToReturnValuePropagation"),
+ not(isPresent()));
// Verify that there are no more conditional instructions.
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
index ae2b510..a73e55f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/EnumMemberValuePropagationTest.java
@@ -53,9 +53,11 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
assertThat(
- testClassSubject.uniqueMethodWithName("deadDueToFieldValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("deadDueToFieldValuePropagation"),
+ not(isPresent()));
assertThat(
- testClassSubject.uniqueMethodWithName("deadDueToReturnValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("deadDueToReturnValuePropagation"),
+ not(isPresent()));
// Verify that there are no more conditional instructions.
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
index 3eb649a..54a69c1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
@@ -48,8 +48,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
index b493f1d..5b50028 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
@@ -77,8 +77,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
index 97dd34c..6cbacd6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FinalFieldWithDefaultValueAssignmentPropagationTest.java
@@ -52,7 +52,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
ClassSubject configClassSubject = inspector.clazz(Config.class);
assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
index 0745620..752e0c6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
@@ -58,7 +58,7 @@
// Verify that all instance-get instructions in testDefinitelyNotNull() has been removed by
// member value propagation.
MethodSubject testDefinitelyNotNullMethodSubject =
- testClassSubject.uniqueMethodWithName("testDefinitelyNotNull");
+ testClassSubject.uniqueMethodWithOriginalName("testDefinitelyNotNull");
assertThat(testDefinitelyNotNullMethodSubject, isPresent());
assertTrue(
testDefinitelyNotNullMethodSubject
@@ -72,7 +72,7 @@
// Verify that all instance-get instructions in testMaybeNull() has been removed by member value
// propagation.
MethodSubject testMaybeNullMethodSubject =
- testClassSubject.uniqueMethodWithName("testMaybeNull");
+ testClassSubject.uniqueMethodWithOriginalName("testMaybeNull");
assertThat(testMaybeNullMethodSubject, isPresent());
assertTrue(
testMaybeNullMethodSubject
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
index 6c7cf37..2ef6259 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.java
@@ -61,7 +61,7 @@
// Verify that the `greeting` field is still present.
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueFieldWithName("greeting"), isPresent());
+ assertThat(aClassSubject.uniqueFieldWithOriginalName("greeting"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
index fb3d7e4..2a2eb77 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithClassInitializationTest.java
@@ -55,17 +55,17 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject fieldSubject = aClassSubject.uniqueFieldWithName("field");
+ FieldSubject fieldSubject = aClassSubject.uniqueFieldWithOriginalName("field");
assertThat(fieldSubject, not(isPresent()));
- FieldSubject clinitFieldSubject = aClassSubject.uniqueFieldWithName("$r8$clinit");
+ FieldSubject clinitFieldSubject = aClassSubject.uniqueFieldWithOriginalName("$r8$clinit");
assertThat(clinitFieldSubject, isPresent());
// B.method() is present.
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject methodSubject = bClassSubject.uniqueMethodWithName("method");
+ MethodSubject methodSubject = bClassSubject.uniqueMethodWithOriginalName("method");
assertThat(methodSubject, not(isPresent()));
// TestClass.missingFieldValuePropagation() and TestClass.missingMethodValuePropagation() are
@@ -73,9 +73,11 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
assertThat(
- testClassSubject.uniqueMethodWithName("missingFieldValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("missingFieldValuePropagation"),
+ not(isPresent()));
assertThat(
- testClassSubject.uniqueMethodWithName("missingMethodValuePropagation"), not(isPresent()));
+ testClassSubject.uniqueMethodWithOriginalName("missingMethodValuePropagation"),
+ not(isPresent()));
// TestClass.main() still accesses A.field and invokes B.method().
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
index 52a163e..a00178c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/MemberValuePropagationWithNewArrayFilledDataTest.java
@@ -48,19 +48,19 @@
assertThat(fontClassSubject, isPresent());
FieldSubject robotoMonoFieldSubject =
- fontClassSubject.uniqueFieldWithName("roboto_mono");
+ fontClassSubject.uniqueFieldWithOriginalName("roboto_mono");
assertThat(robotoMonoFieldSubject, not(isPresent()));
FieldSubject robotoMonoBoldFieldSubject =
- fontClassSubject.uniqueFieldWithName("roboto_mono_bold");
+ fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_bold");
assertThat(robotoMonoBoldFieldSubject, not(isPresent()));
FieldSubject robotoMonoRegularFieldSubject =
- fontClassSubject.uniqueFieldWithName("roboto_mono_regular");
+ fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_regular");
assertThat(robotoMonoRegularFieldSubject, not(isPresent()));
FieldSubject robotoMonoWeightsFieldSubject =
- fontClassSubject.uniqueFieldWithName("roboto_mono_weights");
+ fontClassSubject.uniqueFieldWithOriginalName("roboto_mono_weights");
assertThat(robotoMonoWeightsFieldSubject, isPresent());
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
index 433ee13..611bf52 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithDefaultValueAssignmentPropagationTest.java
@@ -54,7 +54,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
ClassSubject configClassSubject = inspector.clazz(Config.class);
assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
index c69ddd6..e9fd562 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonFinalFieldWithNonDefaultValueAssignmentPropagationTest.java
@@ -54,7 +54,7 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
// TODO(b/147799637): Should be absent.
- assertThat(testClassSubject.uniqueMethodWithName("dead"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), isPresent());
ClassSubject configClassSubject = inspector.clazz(Config.class);
assertThat(configClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
index fba6f58..1aa4d4b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentForwardingConstructorTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
index b6fe557..2de70ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
index 97b57f4..e9a9f9e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentSubtypeTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), isAbsent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
index ca34efd..d0698d2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantArgumentTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
index 0902756..3710a80 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByConstantInOneConstructorTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
index c3a453d..8eced2c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByDifferentConstantsInMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
index c89cfa9..cc6c98c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInForwardingConstructorTest.java
@@ -51,8 +51,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
index 9ffd5ee..8634896 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
@@ -52,8 +52,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
index c515e70..d0e1260 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
index 3033e29..1dba47d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedBySameConstantInMultipleConstructorsTest.java
@@ -50,8 +50,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
index bf1ec2e..5e553e4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldTypeStrengtheningTest.java
@@ -47,7 +47,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject fieldSubject = mainClassSubject.uniqueFieldWithName("f");
+ FieldSubject fieldSubject = mainClassSubject.uniqueFieldWithOriginalName("f");
assertEquals(
aClassSubject.getFinalName(), fieldSubject.getField().getType().getTypeName());
})
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
index 4c19863..eec914f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullFieldAccessTest.java
@@ -49,9 +49,9 @@
private void verifyNonNullPropagation(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
- assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("inlineable"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
index a6f8740..557be25 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/RequireNonNullTest.java
@@ -52,8 +52,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
index baf0868..8418f9c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
@@ -66,7 +66,7 @@
private void inspect(CodeInspector inspector) {
if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
ClassSubject interfaceSubject = inspector.clazz(I.class);
- MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+ MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithOriginalName("greet");
assertThat(interfaceSubject, isPresent());
assertThat(greetMethodSubject, isPresent());
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
index e1763f1..2bbb1b6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromStaticInterfaceMethodTest.java
@@ -68,7 +68,7 @@
: inspector.clazz(I.class.getTypeName() + getCompanionClassNameSuffix());
assertThat(interfaceSubject, isPresent());
- MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+ MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithOriginalName("greet");
assertThat(greetMethodSubject, isPresent());
assertEquals(
1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
index 696a413..69b56ce 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlinesWithNonNullTest.java
@@ -88,24 +88,24 @@
ClassSubject outlineClass =
inspector.clazz(SyntheticItemsTestUtils.syntheticOutlineClass(main, 0));
MethodSubject outlineMethod =
- outlineClass.uniqueMethodWithName(SyntheticItemsTestUtils.syntheticMethodName());
+ outlineClass.uniqueMethodWithOriginalName(SyntheticItemsTestUtils.syntheticMethodName());
assertThat(outlineMethod, isPresent());
ClassSubject argClass = inspector.clazz(TestArg.class);
assertThat(argClass, isPresent());
- MethodSubject printHash = argClass.uniqueMethodWithName("printHash");
+ MethodSubject printHash = argClass.uniqueMethodWithOriginalName("printHash");
assertThat(printHash, isPresent());
- MethodSubject printArg= argClass.uniqueMethodWithName("printArg");
+ MethodSubject printArg = argClass.uniqueMethodWithOriginalName("printArg");
assertThat(printArg, isPresent());
ClassSubject classSubject = inspector.clazz(main);
assertThat(classSubject, isPresent());
- MethodSubject method1 = classSubject.uniqueMethodWithName("method1");
+ MethodSubject method1 = classSubject.uniqueMethodWithOriginalName("method1");
assertThat(method1, isPresent());
assertThat(method1, CodeMatchers.invokesMethod(outlineMethod));
assertThat(method1, not(CodeMatchers.invokesMethod(printHash)));
assertThat(method1, not(CodeMatchers.invokesMethod(printArg)));
- MethodSubject method2 = classSubject.uniqueMethodWithName("method2");
+ MethodSubject method2 = classSubject.uniqueMethodWithOriginalName("method2");
assertThat(method2, isPresent());
assertThat(method2, CodeMatchers.invokesMethod(outlineMethod));
assertThat(method2, not(CodeMatchers.invokesMethod(printHash)));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
index 63aed12..7325c71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithClassArrayTypeArguments.java
@@ -48,9 +48,11 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(
- classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method1"),
+ CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method2"),
+ CodeMatchers.invokesMethod(outline0Method));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
index 4f6a822..7b7c6c3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithInterfaceArrayTypeArguments.java
@@ -57,9 +57,11 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(
- classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method1"),
+ CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method2"),
+ CodeMatchers.invokesMethod(outline0Method));
} else {
assertThat(outlineClass, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
index 2065f83..3939dd0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/arraytypes/OutlinesWithPrimitiveArrayTypeArguments.java
@@ -47,9 +47,11 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(
- classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method1"),
+ CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method2"),
+ CodeMatchers.invokesMethod(outline0Method));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
index ee81c79..fcada92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
@@ -51,10 +51,10 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(
- classSubject.uniqueMethodWithName("ifaceMethod"),
+ classSubject.uniqueMethodWithOriginalName("ifaceMethod"),
CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("methodWithOutlineContent"),
+ classSubject.uniqueMethodWithOriginalName("methodWithOutlineContent"),
CodeMatchers.invokesMethod(outline0Method));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
index 0d1f637..ee43078 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
@@ -108,10 +108,14 @@
// Verify they are called from the feature methods.
// Note: should the choice of synthetic grouping change these expectations will too.
- assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
- assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
- assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
- assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
+ assertTrue(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method1"), outlineClassName));
+ assertTrue(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method2"), outlineClassName));
+ assertTrue(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method3"), outlineClassName));
+ assertTrue(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method4"), outlineClassName));
compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("123456");
}
@@ -160,10 +164,14 @@
.inverse
.get(SyntheticItemsTestUtils.syntheticOutlineClass(TestClass.class, 0).getTypeName());
- assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
- assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
- assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
- assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
+ assertFalse(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method1"), outlineClassName));
+ assertFalse(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method2"), outlineClassName));
+ assertFalse(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method3"), outlineClassName));
+ assertFalse(
+ invokesOutline(featureClass.uniqueMethodWithOriginalName("method4"), outlineClassName));
// Run the code without the feature code present.
compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("12");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
index 9437d1d..29690ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/classtypes/B134462736.java
@@ -54,9 +54,11 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(
- classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method1"),
+ CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method2"),
+ CodeMatchers.invokesMethod(outline0Method));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
index 8385328..81f4c01 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/primitivetypes/PrimitiveTypesTest.java
@@ -62,9 +62,11 @@
assertThat(outline0Method, isPresent());
ClassSubject classSubject = inspector.clazz(testClass);
assertThat(
- classSubject.uniqueMethodWithName("method1"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method1"),
+ CodeMatchers.invokesMethod(outline0Method));
assertThat(
- classSubject.uniqueMethodWithName("method2"), CodeMatchers.invokesMethod(outline0Method));
+ classSubject.uniqueMethodWithOriginalName("method2"),
+ CodeMatchers.invokesMethod(outline0Method));
}
public void runTest(Class<?> testClass, String argumentType, String expectedOutput)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
index b5c1de5..95b0a58 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantarraygetelimination/RedundantArrayGetEliminationTest.java
@@ -61,15 +61,23 @@
private void inspect(CodeInspector inspector) {
ClassSubject mainClassSubject = inspector.clazz(Main.class);
- assertArrayGetCountEquals(1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGet"));
assertArrayGetCountEquals(
- 1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGetAfterPutToUnrelatedArray"));
+ 1, mainClassSubject.uniqueMethodWithOriginalName("testRedundantArrayGet"));
assertArrayGetCountEquals(
- 1, mainClassSubject.uniqueMethodWithName("testRedundantArrayGetAfterPutToUnrelatedIndex"));
+ 1,
+ mainClassSubject.uniqueMethodWithOriginalName(
+ "testRedundantArrayGetAfterPutToUnrelatedArray"));
assertArrayGetCountEquals(
- 2, mainClassSubject.uniqueMethodWithName("testNecessaryArrayGetAfterAliasedArrayPut"));
+ 1,
+ mainClassSubject.uniqueMethodWithOriginalName(
+ "testRedundantArrayGetAfterPutToUnrelatedIndex"));
assertArrayGetCountEquals(
- 2, mainClassSubject.uniqueMethodWithName("testNecessaryArrayGetAfterExternalSideEffect"));
+ 2,
+ mainClassSubject.uniqueMethodWithOriginalName("testNecessaryArrayGetAfterAliasedArrayPut"));
+ assertArrayGetCountEquals(
+ 2,
+ mainClassSubject.uniqueMethodWithOriginalName(
+ "testNecessaryArrayGetAfterExternalSideEffect"));
}
static void assertArrayGetCountEquals(int expected, MethodSubject methodSubject) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
index af7854c..6ea3dcf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalInstanceFieldLoadAfterStoreTest.java
@@ -59,7 +59,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithName("f");
+ FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithOriginalName("f");
assertThat(fFieldSubject, isPresent());
MethodSubject initMethodSubject = aClassSubject.init();
@@ -69,7 +69,7 @@
countInstanceGetInstructions(
initMethodSubject.asFoundMethodSubject(), fFieldSubject.asFoundFieldSubject()));
- MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithName("m");
+ MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
assertThat(mMethodSubject, isPresent());
assertEquals(
2,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
index 701c43f..1bbe682 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantFinalStaticFieldLoadAfterStoreTest.java
@@ -53,7 +53,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithName("f");
+ FieldSubject fFieldSubject = aClassSubject.uniqueFieldWithOriginalName("f");
assertThat(fFieldSubject, isPresent());
MethodSubject initMethodSubject = aClassSubject.clinit();
@@ -63,7 +63,7 @@
countStaticGetInstructions(
initMethodSubject.asFoundMethodSubject(), fFieldSubject.asFoundFieldSubject()));
- MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithName("m");
+ MethodSubject mMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
assertThat(mMethodSubject, isPresent());
assertEquals(
1,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
index d7e4296..99a6045 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInitClassBeforeInvokeStaticTest.java
@@ -43,8 +43,8 @@
inspector -> {
ClassSubject greeterClassSubject = inspector.clazz(Greeter.class);
assertThat(greeterClassSubject, isPresent());
- assertThat(greeterClassSubject.uniqueMethodWithName("hello"), isAbsent());
- assertThat(greeterClassSubject.uniqueMethodWithName("world"), isPresent());
+ assertThat(greeterClassSubject.uniqueMethodWithOriginalName("hello"), isAbsent());
+ assertThat(greeterClassSubject.uniqueMethodWithOriginalName("world"), isPresent());
assertEquals(0, greeterClassSubject.allFields().size());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
index 73e21ba..25987d2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantInstanceFieldLoadAfterStoreTest.java
@@ -45,7 +45,7 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
assertThat(fieldSubject, isAbsent());
})
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
index 936b777..0ea210f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/RedundantStaticFieldLoadAfterStoreTest.java
@@ -46,7 +46,7 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
assertThat(fieldSubject, isAbsent());
MethodSubject methodSubject = classSubject.mainMethod();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
index 908ce00..a50261b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
@@ -170,10 +170,11 @@
ClassSubject reflectionClass = codeInspector.clazz(Reflection.class);
assertThat(reflectionClass, isPresent());
assertThat(
- reflectionClass.uniqueMethodWithName("call"), onlyIf(expectCallPresent, isPresent()));
+ reflectionClass.uniqueMethodWithOriginalName("call"),
+ onlyIf(expectCallPresent, isPresent()));
ClassSubject getterClass = codeInspector.clazz(GetClassTestMain.class);
- MethodSubject getMainClass = getterClass.uniqueMethodWithName("getMainClass");
+ MethodSubject getMainClass = getterClass.uniqueMethodWithOriginalName("getMainClass");
assertThat(getMainClass, isPresent());
// Because of nullable argument, getClass() should remain.
assertEquals(1, countGetClass(getMainClass));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
index a6d3931..581caa9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
@@ -169,7 +169,7 @@
if (isOptimizing) {
ClassSubject testHelperClassSubject = codeInspector.clazz(TestHelper.class);
assertThat(testHelperClassSubject, isPresent());
- assertThat(testHelperClassSubject.uniqueMethodWithName("getClassName"), isAbsent());
+ assertThat(testHelperClassSubject.uniqueMethodWithOriginalName("getClassName"), isAbsent());
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
index 66ae08d..813fdfc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/TestClassForNameWhenSplit.java
@@ -51,19 +51,19 @@
.setMinApi(parameters.getApiLevel())
.addFeatureSplit(
builder ->
- SplitterTestBase.simpleSplitProvider(
- builder, featurePath, temp, Foobar.class))
+ SplitterTestBase.simpleSplitProvider(builder, featurePath, temp, Foobar.class))
.addKeepMainRule(Main.class)
.addKeepClassRules(Foobar.class)
.enableInliningAnnotations()
.compile()
- .inspect(codeInspector -> {
- ClassSubject mainClass = codeInspector.clazz(Main.class);
- MethodSubject foo = mainClass.uniqueMethodWithName("foo");
- assertThat(foo, isPresent());
- // Make sure Class#forName is indeed kept.
- assertEquals(1, countForName(foo));
- })
+ .inspect(
+ codeInspector -> {
+ ClassSubject mainClass = codeInspector.clazz(Main.class);
+ MethodSubject foo = mainClass.uniqueMethodWithOriginalName("foo");
+ assertThat(foo, isPresent());
+ // Make sure Class#forName is indeed kept.
+ assertEquals(1, countForName(foo));
+ })
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
index 4032c83..9cf458d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
@@ -422,13 +422,13 @@
ClassSubject clazz = inspector.clazz(main);
// Check that "calledTwice" is removed (inlined into main).
- assertThat(clazz.uniqueMethodWithName("calledTwice"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("calledTwice"), not(isPresent()));
// Check that the two inlines of "calledTwice" is correctly rewritten.
ClassSubject candidateClassSubject = inspector.clazz(Candidate.class);
assertThat(candidateClassSubject, isPresent());
- assertThat(candidateClassSubject.uniqueMethodWithName("foo"), isPresent());
- assertThat(candidateClassSubject.uniqueMethodWithName("bar"), isPresent());
+ assertThat(candidateClassSubject.uniqueMethodWithOriginalName("foo"), isPresent());
+ assertThat(candidateClassSubject.uniqueMethodWithOriginalName("bar"), isPresent());
assertEquals(
Lists.newArrayList(
"STATIC: String dualcallinline.Candidate.foo()",
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
index be47557..bb1849e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionAsArgumentTest.java
@@ -53,7 +53,7 @@
// Check if the candidate is not staticized.
ClassSubject companion = inspector.clazz(Host.Companion.class);
assertThat(companion, isPresent());
- MethodSubject foo = companion.uniqueMethodWithName("foo");
+ MethodSubject foo = companion.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
assertTrue(
foo.streamInstructions().anyMatch(
@@ -63,7 +63,7 @@
// Nothing migrated from Companion to Host.
ClassSubject host = inspector.clazz(Host.class);
assertThat(host, isPresent());
- MethodSubject migrated_foo = host.uniqueMethodWithName("foo");
+ MethodSubject migrated_foo = host.uniqueMethodWithOriginalName("foo");
assertThat(migrated_foo, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
index 76bee19..1e89087 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/CompanionClassWithNewInstanceUserTest.java
@@ -51,7 +51,8 @@
ClassSubject companionClassSubject = inspector.clazz(Companion.class);
assertThat(companionClassSubject, isPresent());
- MethodSubject companionMethodSubject = companionClassSubject.uniqueMethodWithName("method");
+ MethodSubject companionMethodSubject =
+ companionClassSubject.uniqueMethodWithOriginalName("method");
assertThat(companionMethodSubject, isPresent());
assertThat(companionMethodSubject, isStatic());
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
index 5dabfaf..1c1c5b5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InstanceInsideCompanionTest.java
@@ -55,14 +55,14 @@
// Check if the instance is gone.
ClassSubject host = inspector.clazz(Candidate.Host.class);
assertThat(host, isPresent());
- FieldSubject instance = host.uniqueFieldWithName("INSTANCE");
+ FieldSubject instance = host.uniqueFieldWithOriginalName("INSTANCE");
assertThat(instance, not(isPresent()));
ClassSubject candidate = inspector.clazz(Candidate.class);
assertThat(candidate, not(isPresent()));
// Check if the candidate method is staticized and migrated.
- MethodSubject foo = host.uniqueMethodWithName("foo");
+ MethodSubject foo = host.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
assertTrue(foo.isStatic());
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
index 9dfcb42..06397fc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/InvokeStaticWithNullOutvalueTest.java
@@ -61,7 +61,7 @@
// Check if the instance is gone.
ClassSubject host = inspector.clazz(Host.class);
assertThat(host, isPresent());
- FieldSubject instance = host.uniqueFieldWithName("companion");
+ FieldSubject instance = host.uniqueFieldWithOriginalName("companion");
assertThat(instance, not(isPresent()));
ClassSubject companion = inspector.clazz(Host.Companion.class);
@@ -71,7 +71,7 @@
// Check if the candidate methods are staticized (if necessary) and migrated.
for (String name : ImmutableList.of("boo", "foo")) {
// TODO(b/158018192): This should be host and not companion.
- MethodSubject oo = companion.uniqueMethodWithName(name);
+ MethodSubject oo = companion.uniqueMethodWithOriginalName(name);
assertThat(oo, isPresent());
assertTrue(oo.isStatic());
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
index f49ca5e..b58fdd7 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/NameThenLengthTest.java
@@ -125,7 +125,7 @@
assertEquals(expectedConstNumberCountInClinit, countNonZeroConstNumber(clinit));
}
- MethodSubject m = mainClass.uniqueMethodWithName("instanceMethod");
+ MethodSubject m = mainClass.uniqueMethodWithOriginalName("instanceMethod");
assertThat(m, isPresent());
assertEquals(expectedStringLengthCountInInstanceMethod, countStringLength(m));
assertEquals(expectedConstNumberCountInInstanceMethod, countNonZeroConstNumber(m));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
index 277e1e3..c015182 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringConcatenationTest.java
@@ -102,7 +102,7 @@
CodeInspector codeInspector = result.inspector();
ClassSubject mainClass = codeInspector.clazz(MAIN);
- MethodSubject method = mainClass.uniqueMethodWithName("unusedBuilder");
+ MethodSubject method = mainClass.uniqueMethodWithOriginalName("unusedBuilder");
if (isR8) {
assertThat(method, not(isPresent()));
} else {
@@ -110,80 +110,80 @@
assertEquals(0, countConstString(method));
}
- method = mainClass.uniqueMethodWithName("trivialSequence");
+ method = mainClass.uniqueMethodWithOriginalName("trivialSequence");
assertThat(method, isPresent());
expectedCount = isReleaseMode ? 1 : 3;
assertEquals(expectedCount, countConstString(method));
- method = mainClass.uniqueMethodWithName("builderWithInitialValue");
+ method = mainClass.uniqueMethodWithOriginalName("builderWithInitialValue");
assertThat(method, isPresent());
expectedCount = isReleaseMode ? 1 : 3;
assertEquals(expectedCount, countConstString(method));
- method = mainClass.uniqueMethodWithName("builderWithCapacity");
+ method = mainClass.uniqueMethodWithOriginalName("builderWithCapacity");
assertThat(method, isPresent());
expectedCount = isReleaseMode ? 1 : 0;
assertEquals(expectedCount, countConstString(method));
- method = mainClass.uniqueMethodWithName("nonStringArgs");
+ method = mainClass.uniqueMethodWithOriginalName("nonStringArgs");
assertThat(method, isPresent());
expectedCount = isReleaseMode ? 1 : 0;
assertEquals(expectedCount, countConstString(method));
- method = mainClass.uniqueMethodWithName("typeConversion");
+ method = mainClass.uniqueMethodWithOriginalName("typeConversion");
assertThat(method, isPresent());
expectedCount = isReleaseMode ? 1 : 0;
assertEquals(expectedCount, countConstString(method));
- method = mainClass.uniqueMethodWithName("typeConversion_withPhis");
+ method = mainClass.uniqueMethodWithOriginalName("typeConversion_withPhis");
assertThat(method, isPresent());
assertEquals(0, countConstString(method));
- method = mainClass.uniqueMethodWithName("nestedBuilders_appendBuilderItself");
+ method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_appendBuilderItself");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 1 : 3, countConstString(method));
- method = mainClass.uniqueMethodWithName("nestedBuilders_appendBuilderResult");
+ method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_appendBuilderResult");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 1 : 3, countConstString(method));
- method = mainClass.uniqueMethodWithName("nestedBuilders_conditional");
+ method = mainClass.uniqueMethodWithOriginalName("nestedBuilders_conditional");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 3 : 4, countConstString(method));
- method = mainClass.uniqueMethodWithName("concatenatedBuilders_init");
+ method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_init");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 1 : 2, countConstString(method));
- method = mainClass.uniqueMethodWithName("concatenatedBuilders_append");
+ method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_append");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 1 : 2, countConstString(method));
- method = mainClass.uniqueMethodWithName("concatenatedBuilders_conditional");
+ method = mainClass.uniqueMethodWithOriginalName("concatenatedBuilders_conditional");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 2 : 4, countConstString(method));
- method = mainClass.uniqueMethodWithName("simplePhi");
+ method = mainClass.uniqueMethodWithOriginalName("simplePhi");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 3 : 4, countConstString(method));
- method = mainClass.uniqueMethodWithName("phiAtInit");
+ method = mainClass.uniqueMethodWithOriginalName("phiAtInit");
assertThat(method, isPresent());
assertEquals(3, countConstString(method));
- method = mainClass.uniqueMethodWithName("phiWithDifferentInits");
+ method = mainClass.uniqueMethodWithOriginalName("phiWithDifferentInits");
assertThat(method, isPresent());
assertEquals(3, countConstString(method));
- method = mainClass.uniqueMethodWithName("conditionalPhiWithoutAppend");
+ method = mainClass.uniqueMethodWithOriginalName("conditionalPhiWithoutAppend");
assertThat(method, isPresent());
assertEquals(isReleaseMode ? 2 : 3, countConstString(method));
- method = mainClass.uniqueMethodWithName("loop");
+ method = mainClass.uniqueMethodWithOriginalName("loop");
assertThat(method, isPresent());
assertEquals(3, countConstString(method));
- method = mainClass.uniqueMethodWithName("loopWithBuilder");
+ method = mainClass.uniqueMethodWithOriginalName("loopWithBuilder");
assertThat(method, isPresent());
assertEquals(2, countConstString(method));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
index 1f7b97d..04b57b2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
@@ -147,7 +147,7 @@
long count = countStringContentChecker(mainMethod);
assertEquals(expectedStringContentCheckerCount, count);
- MethodSubject argCouldBeNull = mainClass.uniqueMethodWithName("argCouldBeNull");
+ MethodSubject argCouldBeNull = mainClass.uniqueMethodWithOriginalName("argCouldBeNull");
assertThat(argCouldBeNull, isPresent());
// Because of nullable argument, all checkers should remain.
assertEquals(10, countStringContentChecker(argCouldBeNull));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
index 6c47b03..381797b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringIsEmptyTest.java
@@ -67,7 +67,7 @@
assertThat(mainMethod, isPresent());
assertEquals(expectedStringIsEmptyCount, countCall(mainMethod, "String", "isEmpty"));
- MethodSubject wrapper = mainClass.uniqueMethodWithName("wrapper");
+ MethodSubject wrapper = mainClass.uniqueMethodWithOriginalName("wrapper");
assertThat(wrapper, isPresent());
// Due to nullable, non-constant argument (w/o call-site optimization), isEmpty() should remain.
assertEquals(1, countCall(wrapper, "String", "isEmpty"));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
index dba68cd..a302652 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
@@ -91,11 +91,11 @@
expectedCount = isR8 ? (parameters.isCfRuntime() ? 2 : 1) : (isRelease ? 1 : 0);
assertEquals(expectedCount, countNullStringNumber(mainMethod));
- MethodSubject hideNPE = mainClass.uniqueMethodWithName("hideNPE");
+ MethodSubject hideNPE = mainClass.uniqueMethodWithOriginalName("hideNPE");
// Due to the nullable argument, valueOf should remain.
assertEquals(1, countCall(hideNPE, "String", "valueOf"));
- MethodSubject uninit = mainClass.uniqueMethodWithName("consumeUninitialized");
+ MethodSubject uninit = mainClass.uniqueMethodWithOriginalName("consumeUninitialized");
assertThat(uninit, isPresent());
expectedCount = isR8 ? 0 : 1;
assertEquals(expectedCount, countCall(uninit, "String", "valueOf"));
@@ -120,7 +120,7 @@
inspector -> {
ClassSubject fooClassSubject = inspector.clazz(Foo.class);
assertThat(fooClassSubject, isPresent());
- assertThat(fooClassSubject.uniqueMethodWithName("getter"), isAbsent());
+ assertThat(fooClassSubject.uniqueMethodWithOriginalName("getter"), isAbsent());
})
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutput(JAVA_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
index 213f02b..11a1e35 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonIntermediateIdValueTest.java
@@ -64,7 +64,8 @@
}
private void verifyRewrittenToIfs(CodeInspector inspector) {
- MethodSubject testMethodSubject = inspector.clazz(Main.class).uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertTrue(testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
index 86e30dc..a5eddd4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchCaseRemovalTest.java
@@ -69,10 +69,11 @@
private void verifyOutput(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
{
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("testSwitchCaseRemoval");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("testSwitchCaseRemoval");
assertThat(methodSubject, isPresent());
assertEquals(
1, methodSubject.streamInstructions().filter(InstructionSubject::isConstNull).count());
@@ -83,14 +84,15 @@
{
MethodSubject methodSubject =
- classSubject.uniqueMethodWithName("testSwitchReplacementWithExplicitDefaultCase");
+ classSubject.uniqueMethodWithOriginalName("testSwitchReplacementWithExplicitDefaultCase");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
}
{
MethodSubject methodSubject =
- classSubject.uniqueMethodWithName("testSwitchReplacementWithoutExplicitDefaultCase");
+ classSubject.uniqueMethodWithOriginalName(
+ "testSwitchReplacementWithoutExplicitDefaultCase");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.streamInstructions().noneMatch(InstructionSubject::isSwitch));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
index ed970af..f258093 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/typechecks/InstanceOfMethodSpecializationTest.java
@@ -65,27 +65,27 @@
private void inspect(CodeInspector inspector) {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
- assertThat(aClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
- assertThat(aClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
- assertThat(aClassSubject.uniqueMethodWithName("isSuper"), isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("isSub"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("isSuper"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("isSub"), isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("isSuper"), not(isPresent()));
- assertThat(bClassSubject.uniqueMethodWithName("isSub"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("isSuper"), not(isPresent()));
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("isSub"), not(isPresent()));
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- assertThat(cClassSubject.uniqueMethodWithName("isA"), not(isPresent()));
- assertThat(cClassSubject.uniqueMethodWithName("isB"), not(isPresent()));
- assertThat(cClassSubject.uniqueMethodWithName("isC"), not(isPresent()));
- assertThat(cClassSubject.uniqueMethodWithName("isSuper"), isPresent());
- assertThat(cClassSubject.uniqueMethodWithName("isSub"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("isA"), not(isPresent()));
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("isB"), not(isPresent()));
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("isC"), not(isPresent()));
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("isSuper"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithOriginalName("isSub"), isPresent());
}
public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
index c12a128..80d38dc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithNonNullParamCheckTest.java
@@ -132,8 +132,8 @@
assertEquals(12, found);
// Check that the method live() has been kept and that dead() has been removed.
- assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("live"), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
// Check that the catch handlers for NullPointerException and RuntimeException have not been
// removed.
@@ -144,7 +144,7 @@
"handleRuntimeExceptionForInvokeStatic",
"handleRuntimeExceptionForInvokeVirtual");
for (String methodName : methodNames) {
- assertThat(testClassSubject.uniqueMethodWithName(methodName), isPresent());
+ assertThat(testClassSubject.uniqueMethodWithOriginalName(methodName), isPresent());
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
index 55889a3..6457961 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InvokeMethodWithReceiverOptimizationTest.java
@@ -81,7 +81,7 @@
assertNotEquals(enableArgumentPropagation, otherClassSubject.isPresent());
// Check that A.method() has been removed.
- assertThat(otherClassSubject.uniqueMethodWithName("method"), not(isPresent()));
+ assertThat(otherClassSubject.uniqueMethodWithOriginalName("method"), not(isPresent()));
// Check that a throw instruction has been inserted into each of the testRewriteToThrowNull*
// methods.
@@ -97,12 +97,14 @@
assertEquals(3, found);
// Check that the method dead() has been removed.
- assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+ assertThat(testClassSubject.uniqueMethodWithOriginalName("dead"), not(isPresent()));
// Check that the catch handlers for NullPointerException and RuntimeException have not been
// removed.
- assertThat(testClassSubject.uniqueMethodWithName("handleNullPointerException"), isPresent());
- assertThat(testClassSubject.uniqueMethodWithName("handleRuntimeException"), isPresent());
+ assertThat(
+ testClassSubject.uniqueMethodWithOriginalName("handleNullPointerException"), isPresent());
+ assertThat(
+ testClassSubject.uniqueMethodWithOriginalName("handleRuntimeException"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
index 4d032c7..4119731 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/LambdaInstantiatedTypeTest.java
@@ -62,7 +62,7 @@
assertThat(classSubject, isPresent());
// Check that the method live() has not been removed.
- assertThat(classSubject.uniqueMethodWithName("live"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("live"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
index 17d3ccc..032b058 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
@@ -64,14 +64,14 @@
ClassSubject factoryClassSubject = inspector.clazz(Factory.class);
MethodSubject createStaticMethodSubject =
- factoryClassSubject.uniqueMethodWithName("createStatic");
+ factoryClassSubject.uniqueMethodWithOriginalName("createStatic");
assertThat(createStaticMethodSubject, isPresent());
assertEquals(1, createStaticMethodSubject.getMethod().getParameters().size());
for (int i = 1; i <= 3; ++i) {
String createStaticWithUnusedMethodName = "createStaticWithUnused" + i;
MethodSubject createStaticWithUnusedMethodSubject =
- factoryClassSubject.uniqueMethodWithName(createStaticWithUnusedMethodName);
+ factoryClassSubject.uniqueMethodWithOriginalName(createStaticWithUnusedMethodName);
assertThat(createStaticWithUnusedMethodSubject, isPresent());
DexMethod method = createStaticWithUnusedMethodSubject.getMethod().getReference();
@@ -80,7 +80,7 @@
}
MethodSubject createStaticWithUnusedMethodSubject =
- factoryClassSubject.uniqueMethodWithName("createStaticWithUnused4");
+ factoryClassSubject.uniqueMethodWithOriginalName("createStaticWithUnused4");
assertThat(createStaticWithUnusedMethodSubject, isPresent());
DexMethod method = createStaticWithUnusedMethodSubject.getMethod().getReference();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
index a04df37..99d3ae2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/SynchronizedMethodTest.java
@@ -57,7 +57,7 @@
.inspector();
ClassSubject clazz = inspector.clazz(A.class);
- MethodSubject method = clazz.uniqueMethodWithName("m");
+ MethodSubject method = clazz.uniqueMethodWithOriginalName("m");
assertThat(method, isPresent());
// The invoke on the uninstantiated turns into a "throw null", and the synchronized method
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
index 65132d2..e46ce92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
@@ -92,12 +92,12 @@
List<MethodSubject> methodSubjects =
ImmutableList.of(
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromStart"),
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromMiddle"),
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromEnd"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromStart"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromMiddle"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromEnd"));
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromStart"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromMiddle"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromEnd"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromStart"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromMiddle"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromEnd"));
for (MethodSubject methodSubject : methodSubjects) {
assertThat(methodSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
index 831330d..0665133 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
@@ -69,16 +69,16 @@
ClassSubject factoryClassSubject = inspector.clazz(Factory.class);
MethodSubject createStaticMethodSubject =
- factoryClassSubject.uniqueMethodWithName("createStatic");
+ factoryClassSubject.uniqueMethodWithOriginalName("createStatic");
assertThat(createStaticMethodSubject, isPresent());
assertTrue(createStaticMethodSubject.getMethod().getReturnType().isVoidType());
MethodSubject createVirtualMethodSubject =
- factoryClassSubject.uniqueMethodWithName("createVirtual");
+ factoryClassSubject.uniqueMethodWithOriginalName("createVirtual");
assertThat(createVirtualMethodSubject, isPresent());
assertTrue(createVirtualMethodSubject.getMethod().getReturnType().isVoidType());
createVirtualMethodSubject =
- inspector.clazz(SubFactory.class).uniqueMethodWithName("createVirtual");
+ inspector.clazz(SubFactory.class).uniqueMethodWithOriginalName("createVirtual");
assertThat(createVirtualMethodSubject, isPresent());
assertTrue(createVirtualMethodSubject.getMethod().getReturnType().isVoidType());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
index 0f5b122..9b355fe 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/EffectivelyUnusedNullableArgumentTest.java
@@ -49,7 +49,7 @@
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
- MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertEquals(1, fooMethodSubject.getProgramMethod().getParameters().size());
assertEquals(
@@ -57,7 +57,7 @@
fooMethodSubject.getProgramMethod().getParameter(0));
assertThat(fooMethodSubject, invokesMethodWithName("getClass"));
- MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(barMethodSubject, isStatic());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
index 2f3e14f..fd8e3ac 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
@@ -90,12 +90,12 @@
List<MethodSubject> methodSubjects =
ImmutableList.of(
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromStart"),
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromMiddle"),
- testClassSubject.uniqueMethodWithName("testRemoveStaticFromEnd"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromStart"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromMiddle"),
- testClassSubject.uniqueMethodWithName("testRemoveVirtualFromEnd"));
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromStart"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromMiddle"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveStaticFromEnd"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromStart"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromMiddle"),
+ testClassSubject.uniqueMethodWithOriginalName("testRemoveVirtualFromEnd"));
for (MethodSubject methodSubject : methodSubjects) {
assertThat(methodSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
index 44c15e6..d595562 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
@@ -62,7 +62,7 @@
ClassSubject classSubject = inspector.clazz(B.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("greeting");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("greeting");
assertThat(methodSubject, isPresent());
assertEquals(
"java.lang.String", methodSubject.getMethod().getReference().proto.parameters.toString());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
index 7527598..1c59e0f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
@@ -74,10 +74,10 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject methodA1Subject = aClassSubject.uniqueMethodWithName("method1");
+ MethodSubject methodA1Subject = aClassSubject.uniqueMethodWithOriginalName("method1");
assertThat(methodA1Subject, isPresent());
- MethodSubject methodA2Subject = aClassSubject.uniqueMethodWithName("method2");
+ MethodSubject methodA2Subject = aClassSubject.uniqueMethodWithOriginalName("method2");
assertThat(methodA2Subject, isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
index a4622bc..3f23ccc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInstanceConstructorTest.java
@@ -67,7 +67,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("<init>");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("<init>");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.getMethod().getReference().proto.parameters.isEmpty());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
index 175b2cb..6b9cb0a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedReceiverTest.java
@@ -44,7 +44,8 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isStatic());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java b/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
index 8add503..3503deb 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/B140588497.java
@@ -46,7 +46,7 @@
ClassSubject c = inspector.clazz(TestClass.class);
assertThat(c, isPresent());
- MethodSubject m = c.uniqueMethodWithName("invokeRangeTest");
+ MethodSubject m = c.uniqueMethodWithOriginalName("invokeRangeTest");
assertThat(m, isPresent());
Iterator<InstructionSubject> it =
m.iterateInstructions(InstructionSubject::isConstNumber);
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index 5cdae5d..253d335 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -150,7 +150,7 @@
}
protected FieldSubject checkFieldIsKept(ClassSubject classSubject, String fieldName) {
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName(fieldName);
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName(fieldName);
assertThat(fieldSubject, isPresent());
return fieldSubject;
}
@@ -175,7 +175,7 @@
}
protected MethodSubject checkMethodIsKept(ClassSubject classSubject, String methodName) {
- MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
return methodSubject;
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
index a664d59..b0f4980 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -74,7 +74,7 @@
// Note that isSupported itself has a parameter whose null check would be inlined
// with -allowaccessmodification.
- MethodSubject isSupported = main.uniqueMethodWithName("isSupported");
+ MethodSubject isSupported = main.uniqueMethodWithOriginalName("isSupported");
assertThat(isSupported, isPresent());
assertEquals(
kotlinc.is(KotlinCompilerVersion.KOTLINC_1_3_72) ? 1 : 0,
@@ -82,7 +82,7 @@
// In general cases, null check won't be invoked only once or twice, hence no subtle
// situation in double inlining.
- MethodSubject containsArray = main.uniqueMethodWithName("containsArray");
+ MethodSubject containsArray = main.uniqueMethodWithOriginalName("containsArray");
assertThat(containsArray, isPresent());
assertEquals(0, countCall(containsArray, "checkParameterIsNotNull"));
});
@@ -127,7 +127,7 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject method = main.uniqueMethodWithName(methodName);
+ MethodSubject method = main.uniqueMethodWithOriginalName(methodName);
assertThat(method, isPresent());
int arity = method.getMethod().getReference().getArity();
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
index 19458e2..7733d48 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -50,7 +50,7 @@
// Arity 2 should appear.
assertTrue(init.iterateInstructions(i -> i.isConstNumber(2)).hasNext());
- MethodSubject invoke = classSubject.uniqueMethodWithName("invoke");
+ MethodSubject invoke = classSubject.uniqueMethodWithOriginalName("invoke");
assertThat(invoke, isPresent());
assertEquals(2, invoke.getMethod().getReference().proto.parameters.size());
}
@@ -66,7 +66,7 @@
inspector.forAllClasses(
classSubject -> {
if (classSubject.getOriginalDescriptor().contains("$js")) {
- MethodSubject get = classSubject.uniqueMethodWithName("get");
+ MethodSubject get = classSubject.uniqueMethodWithOriginalName("get");
assertThat(get, isPresent());
assertEquals(3, get.getMethod().getReference().proto.parameters.size());
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
index 692f73b..959042b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -84,7 +84,7 @@
.count());
// The field `INSTANCE` has been removed entirely.
- FieldSubject instance = module.uniqueFieldWithName("INSTANCE");
+ FieldSubject instance = module.uniqueFieldWithOriginalName("INSTANCE");
assertThat(instance, not(isPresent()));
// The class initializer is no longer there.
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index 488271b..517fb4d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -65,7 +65,8 @@
checkMethodPresenceInInput(clazz.getOriginalName(), testMethodSignature, true);
// Find forMakeAndModel(...) after parameter removal.
- MethodSubject testMethod = clazz.uniqueMethodWithName(testMethodSignature.name);
+ MethodSubject testMethod =
+ clazz.uniqueMethodWithOriginalName(testMethodSignature.name);
long ifzCount =
testMethod
.streamInstructions()
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
index 2f27ec3..81b06b4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
@@ -65,10 +65,10 @@
codeInspector -> {
final ClassSubject clazz = codeInspector.clazz("kotlin.Metadata");
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName("pn"), isPresent());
- assertThat(clazz.uniqueMethodWithName("d1"), not(isPresent()));
- assertThat(clazz.uniqueMethodWithName("d2"), not(isPresent()));
- assertThat(clazz.uniqueMethodWithName("bv"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("pn"), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName("d1"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("d2"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("bv"), not(isPresent()));
})
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
index 29b0027..6afe963 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
@@ -131,7 +131,7 @@
// TODO(b/154348683): Assert equality between LibReference and Lib.
// assertEqualMetadata(new CodeInspector(libReferenceJars.get(targetVersion)), inspector);
ClassSubject lib = inspector.clazz(PKG_LIB + ".Lib");
- MethodSubject funInline = lib.uniqueMethodWithName("funInline$main");
+ MethodSubject funInline = lib.uniqueMethodWithOriginalName("funInline$main");
assertThat(funInline, isPresent());
// TODO(b/154348683): Keep the inline method package private.
// assertTrue(funInline.isPackagePrivate());
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
index eb588bb..2232747 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -186,15 +186,15 @@
}
// The backing field for the property in the companion, with @JvmField
- FieldSubject elt2 = impl.uniqueFieldWithName("elt2");
+ FieldSubject elt2 = impl.uniqueFieldWithOriginalName("elt2");
assertThat(elt2, isPresentAndNotRenamed());
- FieldSubject companionObject = impl.uniqueFieldWithName("Companion");
+ FieldSubject companionObject = impl.uniqueFieldWithOriginalName("Companion");
assertThat(companionObject, isPresentAndNotRenamed());
assertEquals(companionObject.getFinalName(), kmClass.getCompanionObject());
// Bridge for the property in the companion that needs a backing field.
- MethodSubject elt1Bridge = impl.uniqueMethodWithName("access$getElt1$cp");
+ MethodSubject elt1Bridge = impl.uniqueMethodWithOriginalName("access$getElt1$cp");
if (keptAll) {
assertThat(elt1Bridge, isPresentAndNotRenamed());
} else {
@@ -202,11 +202,11 @@
}
// With @JvmField, no bridge is added.
- MethodSubject elt2Bridge = impl.uniqueMethodWithName("access$getElt2$cp");
+ MethodSubject elt2Bridge = impl.uniqueMethodWithOriginalName("access$getElt2$cp");
assertThat(elt2Bridge, not(isPresent()));
// For B$Companion.foo, which is a simple computation, no backing field needed, hence no bridge.
- MethodSubject fooBridge = impl.uniqueMethodWithName("access$getFoo$cp");
+ MethodSubject fooBridge = impl.uniqueMethodWithOriginalName("access$getFoo$cp");
assertThat(fooBridge, not(isPresent()));
ClassSubject companion = inspector.clazz(companionClassName);
@@ -226,17 +226,17 @@
kmProperty = kmClass.kmPropertyWithUniqueName("foo");
assertThat(kmProperty, isPresent());
- MethodSubject elt1Getter = companion.uniqueMethodWithName("getElt1");
+ MethodSubject elt1Getter = companion.uniqueMethodWithOriginalName("getElt1");
assertThat(elt1Getter, isPresentAndNotRenamed());
// Note that there is no getter for property with @JvmField.
- MethodSubject elt2Getter = companion.uniqueMethodWithName("getElt2");
+ MethodSubject elt2Getter = companion.uniqueMethodWithOriginalName("getElt2");
assertThat(elt2Getter, not(isPresent()));
- MethodSubject fooGetter = companion.uniqueMethodWithName("getFoo");
+ MethodSubject fooGetter = companion.uniqueMethodWithOriginalName("getFoo");
assertThat(fooGetter, isPresentAndNotRenamed());
- MethodSubject barSetter = companion.uniqueMethodWithName("setBar");
+ MethodSubject barSetter = companion.uniqueMethodWithOriginalName("setBar");
assertThat(barSetter, isPresentAndNotRenamed());
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
index 99cdd63..eefafd8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -222,7 +222,7 @@
// name by changing the import statement and the actual call.
String[] methodNames = new String[] {"extension", "csHash", "longArrayHash", "myApply"};
for (String methodName : methodNames) {
- MethodSubject method = clazz.uniqueMethodWithName(methodName);
+ MethodSubject method = clazz.uniqueMethodWithOriginalName(methodName);
assertThat(method, isPresentAndRenamed());
String finalMethodName = method.getFinalName();
kotlinSource =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
index 9ae2cb0..21ec2b1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -189,7 +189,7 @@
ClassSubject sup = inspector.clazz(superClassName);
assertThat(sup, isPresentAndRenamed());
- MethodSubject foo = sup.uniqueMethodWithName("foo");
+ MethodSubject foo = sup.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresentAndRenamed());
KmClassSubject kmClass = sup.getKmClass();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
index a4cc7fa..8fde8b1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
@@ -110,10 +110,10 @@
ClassSubject libKt = inspector.clazz(libClassName);
assertThat(libKt, isPresentAndNotRenamed());
- MethodSubject methodSubject = libKt.uniqueMethodWithName("applyMap");
+ MethodSubject methodSubject = libKt.uniqueMethodWithOriginalName("applyMap");
assertThat(methodSubject, isPresentAndNotRenamed());
- methodSubject = libKt.uniqueMethodWithName("applyMap$default");
+ methodSubject = libKt.uniqueMethodWithOriginalName("applyMap$default");
assertThat(methodSubject, isPresentAndNotRenamed());
KmPackageSubject kmPackage = libKt.getKmPackage();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
index 435266f..18666b3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
@@ -118,13 +118,13 @@
ClassSubject cls = inspector.clazz(className);
assertThat(cls, isPresentAndNotRenamed());
- MethodSubject foo = cls.uniqueMethodWithName("foo");
+ MethodSubject foo = cls.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresentAndNotRenamed());
ClassSubject libKt = inspector.clazz(libClassName);
assertThat(libKt, isPresentAndNotRenamed());
- MethodSubject bar = libKt.uniqueMethodWithName("bar");
+ MethodSubject bar = libKt.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresentAndNotRenamed());
KmPackageSubject kmPackage = libKt.getKmPackage();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
index 11c9e7b..4168248 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
@@ -110,9 +110,9 @@
ClassSubject util = inspector.clazz(utilClassName);
assertThat(util, isPresentAndNotRenamed());
- MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+ MethodSubject commaJoinOfInt = util.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
assertThat(commaJoinOfInt, isPresentAndNotRenamed());
- MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+ MethodSubject joinOfInt = util.uniqueMethodWithOriginalName("joinOfInt");
assertThat(joinOfInt, not(isPresent()));
inspectMetadataForFacade(inspector, util);
@@ -155,9 +155,9 @@
ClassSubject util = inspector.clazz(utilClassName);
assertThat(util, isPresentAndNotRenamed());
- MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+ MethodSubject commaJoinOfInt = util.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
assertThat(commaJoinOfInt, isPresentAndNotRenamed());
- MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+ MethodSubject joinOfInt = util.uniqueMethodWithOriginalName("joinOfInt");
assertThat(joinOfInt, isPresentAndRenamed());
inspectMetadataForFacade(inspector, util);
@@ -187,9 +187,9 @@
String signedClassName = PKG + ".multifileclass_lib.UtilKt__SignedKt";
ClassSubject signed = inspector.clazz(signedClassName);
assertThat(signed, isPresentAndRenamed());
- MethodSubject commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
+ MethodSubject commaJoinOfInt = signed.uniqueMethodWithOriginalName("commaSeparatedJoinOfInt");
assertThat(commaJoinOfInt, isPresentAndNotRenamed());
- MethodSubject joinOfInt = signed.uniqueMethodWithName("joinOfInt");
+ MethodSubject joinOfInt = signed.uniqueMethodWithOriginalName("joinOfInt");
assertThat(joinOfInt, isPresentAndRenamed());
// API entry is kept, hence the presence of Metadata.
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
index f93a28d..494d25d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -114,11 +114,11 @@
ClassSubject person = inspector.clazz(personClassName);
assertThat(person, isPresentAndNotRenamed());
- FieldSubject backingField = person.uniqueFieldWithName("name");
+ FieldSubject backingField = person.uniqueFieldWithOriginalName("name");
assertThat(backingField, isPresentAndRenamed());
- MethodSubject getterForName = person.uniqueMethodWithName("getName");
+ MethodSubject getterForName = person.uniqueMethodWithOriginalName("getName");
assertThat(getterForName, isPresentAndNotRenamed());
- MethodSubject setterForName = person.uniqueMethodWithName("setName");
+ MethodSubject setterForName = person.uniqueMethodWithOriginalName("setName");
assertThat(setterForName, not(isPresent()));
// API entry is kept, hence the presence of Metadata.
@@ -250,7 +250,7 @@
KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
assertThat(familyName, not(isPresent()));
- FieldSubject ageField = person.uniqueFieldWithName("age");
+ FieldSubject ageField = person.uniqueFieldWithOriginalName("age");
assertThat(ageField, isAbsent());
KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
index 5272541..2571322 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -164,7 +164,7 @@
ClassSubject libKt = inspector.clazz(libKtClassName);
assertThat(libKt, isPresentAndNotRenamed());
- MethodSubject seq = libKt.uniqueMethodWithName("seq");
+ MethodSubject seq = libKt.uniqueMethodWithOriginalName("seq");
assertThat(seq, isPresentAndNotRenamed());
// API entry is kept, hence the presence of Metadata.
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
index cd667d3..a1b423d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
@@ -145,7 +145,7 @@
private void inspectInterfaceWithCompanion(CodeInspector inspector) {
ClassSubject itf = inspector.clazz(PKG_LIB + ".InterfaceWithCompanion");
assertThat(itf, isPresent());
- MethodSubject greet = itf.uniqueMethodWithName("greet");
+ MethodSubject greet = itf.uniqueMethodWithOriginalName("greet");
assertThat(greet, isPresent());
ClassSubject itfCompanion = inspector.clazz(PKG_LIB + ".InterfaceWithCompanion$Companion");
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
index 783b9f1..69643e1 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
@@ -65,7 +65,7 @@
// cast.
ClassSubject clazz = inspector.clazz(Main.class);
assertThat(clazz, isPresentAndNotRenamed());
- MethodSubject main = clazz.uniqueMethodWithName("main");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
assertThat(main, isPresent());
List<CheckCastInstructionSubject> checkCasts =
main.streamInstructions()
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
index 47bd62e..f5aae43 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
@@ -95,17 +95,17 @@
CodeInspector inspector = compileResult.inspector();
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
ClassSubject main2ClassSubject = inspector.clazz(Main2.class);
assertThat(main2ClassSubject, isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(barMethodSubject, isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+ MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
assertThat(bazMethodSubject, isPresent());
assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
assertThat(barMethodSubject, invokesMethod(bazMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
index 013fdd3..b2f82c7 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
@@ -95,19 +95,19 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(barMethodSubject, isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+ MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
assertThat(bazMethodSubject, isPresent());
assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
index 50e65c9..6f97deb 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
@@ -99,23 +99,23 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
MethodSubject notCalledAtStartupMethodSubject =
- mainClassSubject.uniqueMethodWithName("notCalledAtStartup");
+ mainClassSubject.uniqueMethodWithOriginalName("notCalledAtStartup");
assertThat(notCalledAtStartupMethodSubject, isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(barMethodSubject, isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+ MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithOriginalName("baz");
assertThat(bazMethodSubject, isPresent());
assertThat(notCalledAtStartupMethodSubject, invokesMethod(barMethodSubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
index 4d59d9b..6cc29ca 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
@@ -112,7 +112,7 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
@@ -121,7 +121,7 @@
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- MethodSubject fooASubject = aClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooASubject = aClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooASubject, isPresent());
assertThat(fooMethodSubject, invokesMethod(fooASubject));
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
index 480abb7..82e102e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
@@ -104,13 +104,13 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject fooAMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooAMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooAMethodSubject, isPresent());
ClassSubject bClassSubject = inspector.clazz(B.class);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
index ee3a60f..1143ca2 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
@@ -69,7 +69,7 @@
assertThat(bSubject, isPresent());
ClassSubject mainSubject = inspector.clazz(Main.class);
assertThat(mainSubject, isPresentAndNotRenamed());
- MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithName("main");
+ MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithOriginalName("main");
assertThat(mainMethodSubject, isPresentAndNotRenamed());
assertTrue(
mainMethodSubject
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
index e472056..d48f547 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/LibraryMemberRebindingInterfaceTest.java
@@ -103,7 +103,7 @@
.inspect(
inspector -> {
MethodSubject testMethodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("test");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertThat(
testMethodSubject,
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
index ee69b91..41ccb91 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInvokeSuperAbstractTest.java
@@ -64,7 +64,7 @@
.inspect(
inspector -> {
MethodSubject getSystemService =
- inspector.clazz(Main.class).uniqueMethodWithName("getSystemService");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("getSystemService");
assertThat(getSystemService, isPresent());
// We should never rebind this call to LibraryBase::getSystemService since this can
// cause errors when verifying the code on a device where the image has a definition
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java b/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
index 2d1b98c..63bc8a6 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/b135627418/B135627418.java
@@ -47,7 +47,7 @@
assertThat(classSubject, isPresent());
assertTrue(
classSubject
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.filter(InstructionSubject::isInvokeVirtual)
.noneMatch(
diff --git a/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java b/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
index eaac9ca..35e8c37 100644
--- a/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
+++ b/src/test/java/com/android/tools/r8/movestringconstants/MoveStringConstantsTest.java
@@ -130,7 +130,7 @@
ClassSubject utilsClassSubject = inspector.clazz(Utils.class);
assertThat(utilsClassSubject, isPresent());
- assertThat(utilsClassSubject.uniqueMethodWithName("throwException"), isPresent());
+ assertThat(utilsClassSubject.uniqueMethodWithOriginalName("throwException"), isPresent());
assertEquals(1, utilsClassSubject.allMethods().size());
}
diff --git a/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java b/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
index 9038f76..7ec987b 100644
--- a/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/AbstractMethodRenamingTest.java
@@ -85,18 +85,18 @@
private void inspect(CodeInspector inspector) {
ClassSubject base = inspector.clazz(Base.class);
assertThat(base, isPresentAndRenamed());
- MethodSubject foo = base.uniqueMethodWithName("foo");
+ MethodSubject foo = base.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresentAndRenamed());
ClassSubject sub1 = inspector.clazz(Sub1.class);
assertThat(sub1, isPresentAndRenamed());
- MethodSubject fooInSub1 = sub1.uniqueMethodWithName("foo");
+ MethodSubject fooInSub1 = sub1.uniqueMethodWithOriginalName("foo");
assertThat(fooInSub1, isPresentAndRenamed());
assertEquals(foo.getFinalName(), fooInSub1.getFinalName());
ClassSubject sub2 = inspector.clazz(Sub1.class);
assertThat(sub2, isPresentAndRenamed());
- MethodSubject fooInSub2 = sub2.uniqueMethodWithName("foo");
+ MethodSubject fooInSub2 = sub2.uniqueMethodWithOriginalName("foo");
assertThat(fooInSub2, isPresentAndRenamed());
assertEquals(foo.getFinalName(), fooInSub2.getFinalName());
}
diff --git a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
index 97073ac..cd8e931 100644
--- a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
@@ -96,7 +96,7 @@
throws NoSuchMethodException {
ClassSubject superInterface = inspector.clazz(SuperInterface.class);
assertThat(superInterface, isPresentAndRenamed());
- MethodSubject foo1 = superInterface.uniqueMethodWithName("foo");
+ MethodSubject foo1 = superInterface.uniqueMethodWithOriginalName("foo");
assertThat(foo1, isPresentAndRenamed());
ClassSubject subInterface = inspector.clazz(SubInterface.class);
assertThat(subInterface, isPresentAndRenamed());
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinification.java b/src/test/java/com/android/tools/r8/naming/EnumMinification.java
index 3cf01e0..95ff741 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinification.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinification.java
@@ -68,13 +68,13 @@
// The class and fields - including the method valueOf - can be renamed. Only the values()
// method needs to be.
assertThat(clazz, isPresentAndRenamed());
- assertThat(clazz.uniqueFieldWithName("VALUE1"), isAbsent());
- assertThat(clazz.uniqueFieldWithName("VALUE2"), isAbsent());
- assertThat(clazz.uniqueFieldWithName("$VALUES"), isPresentAndRenamed());
+ assertThat(clazz.uniqueFieldWithOriginalName("VALUE1"), isAbsent());
+ assertThat(clazz.uniqueFieldWithOriginalName("VALUE2"), isAbsent());
+ assertThat(clazz.uniqueFieldWithOriginalName("$VALUES"), isPresentAndRenamed());
assertThat(
- clazz.uniqueMethodWithName("valueOf"),
+ clazz.uniqueMethodWithOriginalName("valueOf"),
valueOfKept ? isPresentAndRenamed() : not(isPresent()));
- assertThat(clazz.uniqueMethodWithName("values"), isPresentAndNotRenamed());
+ assertThat(clazz.uniqueMethodWithOriginalName("values"), isPresentAndNotRenamed());
}
@Test
diff --git a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
index 7d0d809..d8e0168 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
@@ -38,10 +38,10 @@
.assertSuccessWithOutput(expectedOutput)
.inspector();
- FieldSubject f1Subject = inspector.clazz(A.class).uniqueFieldWithName("f1");
+ FieldSubject f1Subject = inspector.clazz(A.class).uniqueFieldWithOriginalName("f1");
assertThat(f1Subject, isPresent());
- FieldSubject f3Subject = inspector.clazz(C.class).uniqueFieldWithName("f3");
+ FieldSubject f3Subject = inspector.clazz(C.class).uniqueFieldWithOriginalName("f3");
assertThat(f3Subject, isPresent());
assertNotEquals(f1Subject.getFinalName(), f3Subject.getFinalName());
diff --git a/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java b/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
index 165d0f7..0fc9365 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
@@ -108,11 +108,16 @@
.assertSuccessWithOutputLines("2HELLO WORLD", "2HELLO WORLD")
.inspect(
inspector -> {
- assertEquals("a", inspector.clazz(A.class).uniqueFieldWithName("f1").getFinalName());
- assertEquals("a", inspector.clazz(B.class).uniqueFieldWithName("f0").getFinalName());
- assertEquals("b", inspector.clazz(B.class).uniqueFieldWithName("f2").getFinalName());
- assertEquals("a", inspector.clazz(C.class).uniqueFieldWithName("f0").getFinalName());
- assertEquals("b", inspector.clazz(C.class).uniqueFieldWithName("f3").getFinalName());
+ assertEquals(
+ "a", inspector.clazz(A.class).uniqueFieldWithOriginalName("f1").getFinalName());
+ assertEquals(
+ "a", inspector.clazz(B.class).uniqueFieldWithOriginalName("f0").getFinalName());
+ assertEquals(
+ "b", inspector.clazz(B.class).uniqueFieldWithOriginalName("f2").getFinalName());
+ assertEquals(
+ "a", inspector.clazz(C.class).uniqueFieldWithOriginalName("f0").getFinalName());
+ assertEquals(
+ "b", inspector.clazz(C.class).uniqueFieldWithOriginalName("f3").getFinalName());
});
}
}
diff --git a/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java b/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
index e3a8047..28d39db 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldSharedParentMinificationTest.java
@@ -42,9 +42,9 @@
.assertSuccessWithOutputLines("true", "42", "Hello World!")
.inspect(
inspector -> {
- FieldSubject foo = inspector.clazz(I.class).uniqueFieldWithName("foo");
- FieldSubject bar = inspector.clazz(J.class).uniqueFieldWithName("bar");
- FieldSubject baz = inspector.clazz(A.class).uniqueFieldWithName("baz");
+ FieldSubject foo = inspector.clazz(I.class).uniqueFieldWithOriginalName("foo");
+ FieldSubject bar = inspector.clazz(J.class).uniqueFieldWithOriginalName("bar");
+ FieldSubject baz = inspector.clazz(A.class).uniqueFieldWithOriginalName("baz");
assertThat(foo, isPresentAndRenamed());
assertThat(bar, isPresentAndRenamed());
assertThat(baz, isPresentAndRenamed());
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
index 6597cb0..dc7f93e 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
@@ -144,7 +144,7 @@
assertEquals(countInMain, renamedYetFoundIdentifierCount);
ClassSubject aClass = inspector.clazz("adaptclassstrings.A");
- MethodSubject bar = aClass.uniqueMethodWithName("bar");
+ MethodSubject bar = aClass.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresent());
verifyPresenceOfConstString(bar);
renamedYetFoundIdentifierCount = countRenamedClassIdentifier(inspector, bar);
@@ -188,7 +188,7 @@
assertEquals(2, constStringInstructions.size());
ClassSubject b = inspector.clazz("getmembers.B");
- MethodSubject inliner = b.uniqueMethodWithName("inliner");
+ MethodSubject inliner = b.uniqueMethodWithOriginalName("inliner");
assertThat(inliner, isPresent());
constStringInstructions = getRenamedMemberIdentifierConstStrings(a, inliner);
assertEquals(1, constStringInstructions.size());
diff --git a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
index 57bd145..8fd083f 100644
--- a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
@@ -75,9 +75,9 @@
codeInspector -> {
ClassSubject clazz = codeInspector.clazz(Main.class);
assertThat(clazz, isPresent());
- MethodSubject aSubject = clazz.uniqueMethodWithName("a");
+ MethodSubject aSubject = clazz.uniqueMethodWithOriginalName("a");
assertThat(aSubject.getFinalName(), anyOf(is("x"), is("y")));
- MethodSubject bSubject = clazz.uniqueMethodWithName("b");
+ MethodSubject bSubject = clazz.uniqueMethodWithOriginalName("b");
assertThat(bSubject.getFinalName(), anyOf(is("x"), is("y")));
});
}
diff --git a/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java b/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
index 166b2e1..d7baa95 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadUniqueNameTest.java
@@ -142,10 +142,13 @@
assertEquals(aFoo.getFinalName(), cFoo.getFinalName());
// Ensure that all SAM interfaces has same method name.
- final MethodSubject i1Foo = codeInspector.clazz(I1.class).uniqueMethodWithName("foo");
- final MethodSubject i2Foo = codeInspector.clazz(I2.class).uniqueMethodWithName("foo");
+ final MethodSubject i1Foo =
+ codeInspector.clazz(I1.class).uniqueMethodWithOriginalName("foo");
+ final MethodSubject i2Foo =
+ codeInspector.clazz(I2.class).uniqueMethodWithOriginalName("foo");
assertEquals(i1Foo.getFinalName(), i2Foo.getFinalName());
- final MethodSubject i3Foo = codeInspector.clazz(I3.class).uniqueMethodWithName("foo");
+ final MethodSubject i3Foo =
+ codeInspector.clazz(I3.class).uniqueMethodWithOriginalName("foo");
assertEquals(i1Foo.getFinalName(), i3Foo.getFinalName());
// Ensure C has the correct name for the interface method.
@@ -154,7 +157,8 @@
assertEquals(cIFoo.getFinalName(), i1Foo.getFinalName());
// Ensure that I4.foo(int) has the same name as I3.foo(int).
- final MethodSubject i4Foo = codeInspector.clazz(I4.class).uniqueMethodWithName("foo");
+ final MethodSubject i4Foo =
+ codeInspector.clazz(I4.class).uniqueMethodWithOriginalName("foo");
assertEquals(i3Foo.getFinalName(), i4Foo.getFinalName());
});
}
diff --git a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
index cda6322..b7176ab 100644
--- a/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/OverloadedReservedFieldNamingTest.java
@@ -62,14 +62,14 @@
assertThat(classSubject, isPresent());
FieldSubject fieldSubject =
- classSubject.asFoundClassSubject().uniqueFieldWithName("a", Reference.BOOL);
+ classSubject.asFoundClassSubject().uniqueFieldWithOriginalName("a", Reference.BOOL);
assertThat(fieldSubject, isPresentAndNotRenamed());
- FieldSubject helloFieldSubject = classSubject.uniqueFieldWithName("hello");
+ FieldSubject helloFieldSubject = classSubject.uniqueFieldWithOriginalName("hello");
assertThat(helloFieldSubject, isPresent());
assertEquals(overloadAggressively ? "a" : "b", helloFieldSubject.getFinalName());
- FieldSubject worldFieldSubject = classSubject.uniqueFieldWithName("world");
+ FieldSubject worldFieldSubject = classSubject.uniqueFieldWithOriginalName("world");
assertThat(worldFieldSubject, isPresent());
assertEquals(overloadAggressively ? "a" : "c", worldFieldSubject.getFinalName());
}
diff --git a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
index 9079f61..487498f 100644
--- a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
@@ -157,7 +157,7 @@
assertFalse(inspector.clazz("naming044.sub.SubB").getFinalName().contains("."));
// Method naming044.B.m would be renamed.
- MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithName("m");
+ MethodSubject mMethodSubject = bClassSubject.uniqueMethodWithOriginalName("m");
assertNotEquals("m", mMethodSubject.getMethod().getName().toSourceString());
}
@@ -197,7 +197,7 @@
b.getDexProgramClass().getType().getPackageName());
// method naming044.B.m would be renamed.
- MethodSubject mMethodSubject = b.uniqueMethodWithName("m");
+ MethodSubject mMethodSubject = b.uniqueMethodWithOriginalName("m");
assertNotEquals("m", mMethodSubject.getMethod().getName().toSourceString());
}
diff --git a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
index cd9d54c..2176526 100644
--- a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
@@ -78,9 +78,9 @@
assertThat(viewModel, isPresentAndRenamed(minification));
ClassSubject subViewModel = inspector.clazz(SubViewModel.class);
assertThat(subViewModel, isPresentAndRenamed(minification));
- MethodSubject viewModelClear = viewModel.uniqueMethodWithName("clear");
+ MethodSubject viewModelClear = viewModel.uniqueMethodWithOriginalName("clear");
assertThat(viewModelClear, isPresentAndRenamed(minification));
- MethodSubject subViewModelClear = subViewModel.uniqueMethodWithName("clear");
+ MethodSubject subViewModelClear = subViewModel.uniqueMethodWithOriginalName("clear");
assertThat(subViewModelClear, isPresentAndRenamed(minification));
assertEquals(viewModelClear.getFinalName(), subViewModelClear.getFinalName());
if (!minification) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
index c4b3181..d7e6e8a 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
@@ -69,10 +69,10 @@
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithName("f1");
+ FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f1");
assertThat(f1FieldSubject, isPresent());
- FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithName("a");
+ FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithOriginalName("a");
assertThat(aFieldSubject, isPresent());
if (reserveName) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
index 38bcbad..4994263 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
@@ -83,22 +83,22 @@
ClassSubject kClassSubject = inspector.clazz(K.class);
assertThat(kClassSubject, isPresent());
- FieldSubject f1FieldSubject = aClassSubject.uniqueFieldWithName("f1");
+ FieldSubject f1FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f1");
assertThat(f1FieldSubject, isPresent());
- FieldSubject f2FieldSubject = bClassSubject.uniqueFieldWithName("f2");
+ FieldSubject f2FieldSubject = bClassSubject.uniqueFieldWithOriginalName("f2");
assertThat(f2FieldSubject, isPresent());
- FieldSubject f3FieldSubject = iClassSubject.uniqueFieldWithName("f3");
+ FieldSubject f3FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f3");
assertThat(f3FieldSubject, isPresent());
- FieldSubject f4FieldSubject = jClassSubject.uniqueFieldWithName("f4");
+ FieldSubject f4FieldSubject = jClassSubject.uniqueFieldWithOriginalName("f4");
assertThat(f4FieldSubject, isPresent());
- FieldSubject f5FieldSubject = kClassSubject.uniqueFieldWithName("f5");
+ FieldSubject f5FieldSubject = kClassSubject.uniqueFieldWithOriginalName("f5");
assertThat(f5FieldSubject, isPresent());
- FieldSubject aFieldSubject = cClassSubject.uniqueFieldWithName("a");
+ FieldSubject aFieldSubject = cClassSubject.uniqueFieldWithOriginalName("a");
assertThat(aFieldSubject, isPresent());
if (reserveName) {
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
index 65c62b8..8298bed 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
@@ -67,11 +67,11 @@
ClassSubject jClassSubject = inspector.clazz(J.class);
assertThat(jClassSubject, isPresent());
- FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithName("f1");
+ FieldSubject f1FieldSubject = iClassSubject.uniqueFieldWithOriginalName("f1");
assertThat(f1FieldSubject, isPresent());
assertThat(f1FieldSubject, isPresentAndRenamed());
- FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithName("a");
+ FieldSubject aFieldSubject = jClassSubject.uniqueFieldWithOriginalName("a");
assertThat(aFieldSubject, isPresent());
if (reserveName) {
@@ -119,7 +119,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithName("f2");
+ FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f2");
assertThat(f2FieldSubject, isPresent());
assertThat(f2FieldSubject, isPresentAndRenamed());
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
index 3c264ae..58dfa65 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperClassTest.java
@@ -59,7 +59,7 @@
ClassSubject testClassForFieldSubject = inspector.clazz(A.class);
assertThat(testClassForFieldSubject, isPresent());
- FieldSubject aFieldSubject = testClassForFieldSubject.uniqueFieldWithName("a");
+ FieldSubject aFieldSubject = testClassForFieldSubject.uniqueFieldWithOriginalName("a");
assertThat(aFieldSubject, isPresent());
// Fields are visited/renamed according to the class hierarchy order. Thus, the field A.a will
@@ -92,14 +92,14 @@
ClassSubject aSub1ClassSubject = inspector.clazz(ASub1.class);
assertThat(aSub1ClassSubject, isPresent());
- FieldSubject fooFieldSubject = aSub1ClassSubject.uniqueFieldWithName("foo");
+ FieldSubject fooFieldSubject = aSub1ClassSubject.uniqueFieldWithOriginalName("foo");
assertThat(fooFieldSubject, isPresentAndRenamed());
assertNotEquals("a", fooFieldSubject.getFinalName());
ClassSubject aSub2ClassSubject = inspector.clazz(ASub2.class);
assertThat(aSub2ClassSubject, isPresent());
- FieldSubject barFieldSubject = aSub2ClassSubject.uniqueFieldWithName("bar");
+ FieldSubject barFieldSubject = aSub2ClassSubject.uniqueFieldWithOriginalName("bar");
assertThat(barFieldSubject, isPresentAndRenamed());
assertNotEquals("a", barFieldSubject.getFinalName());
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
index 599799e..2760aec 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSuperInterfaceTest.java
@@ -60,7 +60,7 @@
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- FieldSubject aFieldSubject = iClassSubject.uniqueFieldWithName("a");
+ FieldSubject aFieldSubject = iClassSubject.uniqueFieldWithOriginalName("a");
assertThat(aFieldSubject, isPresent());
// Interface fields are visited/renamed before fields on classes. Thus, the interface field I.a
@@ -93,7 +93,7 @@
ClassSubject jClassSubject = inspector.clazz(J.class);
assertThat(jClassSubject, isPresent());
- FieldSubject f1FieldSubject = jClassSubject.uniqueFieldWithName("f1");
+ FieldSubject f1FieldSubject = jClassSubject.uniqueFieldWithOriginalName("f1");
assertThat(f1FieldSubject, isPresent());
assertThat(f1FieldSubject, isPresentAndRenamed());
assertEquals("b", f1FieldSubject.getFinalName());
@@ -101,7 +101,7 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithName("f2");
+ FieldSubject f2FieldSubject = aClassSubject.uniqueFieldWithOriginalName("f2");
assertThat(f2FieldSubject, isPresent());
assertThat(f2FieldSubject, isPresentAndRenamed());
assertEquals("c", f2FieldSubject.getFinalName());
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
index 3d4b859..b0f1a96 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingKeepPrecedenceTest.java
@@ -104,10 +104,10 @@
ClassSubject clazzB = codeInspector.clazz(B.class);
assertTrue(clazzB.isPresent());
assertTrue(clazzB.isRenamed());
- FieldSubject foo = clazzB.uniqueFieldWithName("foo");
+ FieldSubject foo = clazzB.uniqueFieldWithOriginalName("foo");
assertTrue(foo.isPresent());
assertFalse(foo.isRenamed());
- MethodSubject bar = clazzB.uniqueMethodWithName("bar");
+ MethodSubject bar = clazzB.uniqueMethodWithOriginalName("bar");
assertTrue(bar.isPresent());
assertFalse(bar.isRenamed());
});
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
index 26873f4..2657ae8 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingLibraryMemberRenamingTests.java
@@ -84,7 +84,7 @@
codeInspector -> {
ClassSubject clazz = codeInspector.clazz(Interface.class);
assertThat(clazz, isPresent());
- MethodSubject computeSubject = clazz.uniqueMethodWithName("compute");
+ MethodSubject computeSubject = clazz.uniqueMethodWithOriginalName("compute");
assertThat(computeSubject, isPresent());
assertTrue(computeSubject.isRenamed());
});
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
index f527ead..afb0b75 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
@@ -113,19 +113,19 @@
ClassSubject clazzA = inspector.clazz(A.class);
assertThat(clazzA, isPresent());
assertEquals("a", clazzA.getFinalName());
- FieldSubject fieldA = clazzA.uniqueFieldWithName("fieldA");
+ FieldSubject fieldA = clazzA.uniqueFieldWithOriginalName("fieldA");
assertThat(fieldA, isPresent());
assertEquals("a", fieldA.getFinalName());
- MethodSubject methodA = clazzA.uniqueMethodWithName("methodA");
+ MethodSubject methodA = clazzA.uniqueMethodWithOriginalName("methodA");
assertThat(methodA, isPresent());
assertEquals("a", methodA.getFinalName());
- FieldSubject fieldB = clazzA.uniqueFieldWithName("fieldB");
+ FieldSubject fieldB = clazzA.uniqueFieldWithOriginalName("fieldB");
assertThat(fieldB, isPresent());
assertTrue(fieldB.isRenamed());
- MethodSubject methodB = clazzA.uniqueMethodWithName("methodB");
+ MethodSubject methodB = clazzA.uniqueMethodWithOriginalName("methodB");
assertThat(methodB, isPresent());
assertTrue(methodB.isRenamed());
- MethodSubject methodC = clazzA.uniqueMethodWithName("methodC");
+ MethodSubject methodC = clazzA.uniqueMethodWithOriginalName("methodC");
assertThat(methodC, isPresent());
assertFalse(methodC.isRenamed());
});
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
index afa76f5..8b4f4e3 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRepackagingTest.java
@@ -103,14 +103,14 @@
ClassSubject clazzA = inspector.clazz(A.class);
assertThat(clazzA, isPresent());
assertEquals("baz", clazzA.getFinalName());
- FieldSubject fieldA = clazzA.uniqueFieldWithName("fieldA");
+ FieldSubject fieldA = clazzA.uniqueFieldWithOriginalName("fieldA");
assertThat(fieldA, isPresent());
assertEquals("foo", fieldA.getFinalName());
- MethodSubject methodA = clazzA.uniqueMethodWithName("methodA");
+ MethodSubject methodA = clazzA.uniqueMethodWithOriginalName("methodA");
assertThat(methodA, isPresent());
assertEquals("bar", methodA.getFinalName());
- assertThat(clazzA.uniqueFieldWithName("fieldB"), isPresentAndRenamed());
- assertThat(clazzA.uniqueMethodWithName("methodB"), isPresentAndRenamed());
+ assertThat(clazzA.uniqueFieldWithOriginalName("fieldB"), isPresentAndRenamed());
+ assertThat(clazzA.uniqueMethodWithOriginalName("methodB"), isPresentAndRenamed());
});
// Ensure that the proguard map is extended with all the new minified names.
for (String pgLine : pgMap) {
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
index 40ba160..5db4da0 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSignatureTest.java
@@ -65,7 +65,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(SignatureTest.class);
assertThat(clazz, isPresent());
- FieldSubject field = clazz.uniqueFieldWithName("field");
+ FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
assertThat(field, isPresent());
assertThat(field.getFinalSignatureAttribute(), containsString("foo"));
});
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
index d195bd3..4eb4585 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/InnerEnumValuesTest.java
@@ -74,10 +74,10 @@
.inspector();
ClassSubject enumSubject = inspector.clazz(RENAMED_NAME);
assertThat(enumSubject, isPresent());
- FieldSubject fieldX = enumSubject.uniqueFieldWithName("STATE_A");
+ FieldSubject fieldX = enumSubject.uniqueFieldWithOriginalName("STATE_A");
assertThat(fieldX, isPresent());
assertEquals("state_X", fieldX.getFinalName());
- FieldSubject fieldY = enumSubject.uniqueFieldWithName("STATE_B");
+ FieldSubject fieldY = enumSubject.uniqueFieldWithOriginalName("STATE_B");
assertThat(fieldY, isPresent());
assertEquals("state_Y", fieldY.getFinalName());
}
diff --git a/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
index 968123a..48ae678 100644
--- a/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b123068484/FieldRenamingTest.java
@@ -75,8 +75,10 @@
}
private void inspect(CodeInspector inspector) {
- FieldSubject fld = inspector.clazz(CONCRETE1.getTypeName().replace("Concrete1", "Abs"))
- .uniqueFieldWithName("strField");
+ FieldSubject fld =
+ inspector
+ .clazz(CONCRETE1.getTypeName().replace("Concrete1", "Abs"))
+ .uniqueFieldWithOriginalName("strField");
assertThat(fld, isPresent());
ClassSubject main = inspector.clazz(MAIN);
diff --git a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
index fb9c53e..3e4d30f 100644
--- a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
+++ b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
@@ -64,7 +64,7 @@
genericTypeDescriptor = genericType.getFinalDescriptor();
}
String expectedSignature = "Ljava/util/List<" + genericTypeDescriptor + ">;";
- FieldSubject list = inspector.clazz(A.class).uniqueFieldWithName("list");
+ FieldSubject list = inspector.clazz(A.class).uniqueFieldWithOriginalName("list");
assertThat(list, isPresent());
assertEquals(expectedSignature, list.getFinalSignatureAttribute());
})
diff --git a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
index 0add817..24fd0b2 100644
--- a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
+++ b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
@@ -39,7 +39,7 @@
inspector -> {
ClassSubject greetingBase = inspector.clazz(Greeting.getGreetingBase());
assertThat(greetingBase, isPresent());
- FieldSubject greeting = greetingBase.uniqueFieldWithName("greeting");
+ FieldSubject greeting = greetingBase.uniqueFieldWithOriginalName("greeting");
assertThat(greeting, isPresentAndRenamed());
assertNotEquals("a", greeting.getFinalName());
});
@@ -86,7 +86,7 @@
inspector -> {
ClassSubject base = inspector.clazz(TestClassBase.class);
assertThat(base, isPresent());
- MethodSubject foo = base.uniqueMethodWithName("foo");
+ MethodSubject foo = base.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresentAndRenamed());
assertNotEquals("a", foo.getFinalName());
});
diff --git a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
index ad2f639..ba6fab5 100644
--- a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
+++ b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
@@ -110,7 +110,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject holder = inspector.clazz(SomeLogic.class);
assertThat(holder, isPresentAndNotRenamed());
- MethodSubject someMethod = holder.uniqueMethodWithName("someMethod");
+ MethodSubject someMethod = holder.uniqueMethodWithOriginalName("someMethod");
assertThat(someMethod, isPresentAndNotRenamed());
}
diff --git a/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
index 8d07717..a987575 100644
--- a/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b133686361/AlreadyRenamedAbstractMethodRenamingTest.java
@@ -92,18 +92,18 @@
private void inspect(CodeInspector inspector) {
ClassSubject base = inspector.clazz(Base.class);
assertThat(base, isPresentAndRenamed());
- MethodSubject a = base.uniqueMethodWithName("a");
+ MethodSubject a = base.uniqueMethodWithOriginalName("a");
assertThat(a, isPresentAndNotRenamed());
ClassSubject sub1 = inspector.clazz(Sub1.class);
assertThat(sub1, isPresentAndRenamed());
- MethodSubject aInSub1 = sub1.uniqueMethodWithName("a");
+ MethodSubject aInSub1 = sub1.uniqueMethodWithOriginalName("a");
assertThat(aInSub1, isPresentAndNotRenamed());
assertEquals(a.getFinalName(), aInSub1.getFinalName());
ClassSubject sub2 = inspector.clazz(Sub1.class);
assertThat(sub2, isPresentAndRenamed());
- MethodSubject aInSub2 = sub2.uniqueMethodWithName("a");
+ MethodSubject aInSub2 = sub2.uniqueMethodWithOriginalName("a");
assertThat(aInSub2, isPresentAndNotRenamed());
assertEquals(a.getFinalName(), aInSub2.getFinalName());
}
diff --git a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
index 470b542..2de209b 100644
--- a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
@@ -11,7 +11,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
@@ -50,9 +49,7 @@
.setSuper(DescriptorUtils.javaTypeToDescriptor(Interface.class.getTypeName()))
.transform())
.build();
- testForExternalR8(
- parameters.getBackend(),
- parameters.isCfRuntime() ? parameters.getRuntime() : TestRuntime.getCheckedInJdk11())
+ testForExternalR8(parameters.getBackend())
.addProgramFiles(classFiles)
.addTestingAnnotationsAsProgramClasses()
.enableAssertions(false)
diff --git a/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java b/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
index 8771ff4..ffdda98 100644
--- a/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
+++ b/src/test/java/com/android/tools/r8/naming/b72391662/B72391662.java
@@ -142,7 +142,7 @@
assertThat(testClass, isPresent());
// Test the totally unused method.
- MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+ MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
assertThat(staticMethod, isPresent());
assertEquals(minify, staticMethod.isRenamed());
if (shrinker.isR8()) {
@@ -152,7 +152,7 @@
}
// Test an indirectly referred method.
- staticMethod = testClass.uniqueMethodWithName("staticMethod");
+ staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
assertThat(staticMethod, isPresent());
assertEquals(minify, staticMethod.isRenamed());
boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
@@ -193,7 +193,7 @@
assertThat(testClass, isPresent());
// Test the totally unused method.
- MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+ MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
assertThat(staticMethod, isPresent());
assertEquals(minify, staticMethod.isRenamed());
if (shrinker.isR8()) {
@@ -203,7 +203,7 @@
}
// Test an indirectly referred method.
- staticMethod = testClass.uniqueMethodWithName("staticMethod");
+ staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
assertThat(staticMethod, isPresent());
assertEquals(minify, staticMethod.isRenamed());
boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
@@ -259,11 +259,11 @@
assertThat(testClass, isPresent());
// Test the totally unused method.
- MethodSubject staticMethod = testClass.uniqueMethodWithName("unused");
+ MethodSubject staticMethod = testClass.uniqueMethodWithOriginalName("unused");
assertThat(staticMethod, not(isPresent()));
// Test an indirectly referred method.
- staticMethod = testClass.uniqueMethodWithName("staticMethod");
+ staticMethod = testClass.uniqueMethodWithOriginalName("staticMethod");
assertThat(staticMethod, isPresent());
assertEquals(minify, staticMethod.isRenamed());
boolean publicizeCondition = shrinker.isR8() ? allowAccessModification
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
index b07255b..db9020d 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineBranchTest.java
@@ -62,7 +62,7 @@
.inspectStackTrace(
(stackTrace, inspector) -> {
MethodSubject methodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("call");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("call");
assertThat(methodSubject, isPresent());
List<InstructionSubject> getClassCalls =
methodSubject
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
index b005549..8362ed6 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineConditionTest.java
@@ -65,7 +65,7 @@
inspector -> {
ClassSubject fooClass = inspector.clazz(Foo.class);
assertThat(fooClass, isPresent());
- MethodSubject inlineable = fooClass.uniqueMethodWithName("inlineable");
+ MethodSubject inlineable = fooClass.uniqueMethodWithOriginalName("inlineable");
assertThat(inlineable, not(isPresent()));
});
compileResult
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
index f3718cd..a68715a 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNoSuchMethodErrorTest.java
@@ -99,7 +99,7 @@
ClassSubject fooClass = codeInspector.clazz(Foo.class);
assertThat(fooClass, isPresent());
// We are not inlining this because resolution fails
- assertThat(fooClass.uniqueMethodWithName("inlinable"), isPresent());
+ assertThat(fooClass.uniqueMethodWithOriginalName("inlinable"), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
index 99531f1..90552b3 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/RetraceInlineeWithNullCheckInlinedTest.java
@@ -67,7 +67,7 @@
(stackTrace, inspector) -> {
ClassSubject callerClass = inspector.clazz(Caller.class);
assertThat(callerClass, isPresent());
- MethodSubject outerCaller = callerClass.uniqueMethodWithName("outerCaller");
+ MethodSubject outerCaller = callerClass.uniqueMethodWithOriginalName("outerCaller");
assertThat(outerCaller, isPresentAndRenamed());
assertThat(stackTrace, isSame(expectedStackTrace));
});
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
index 1e2140c..f8ad999 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagationToClassesOutsideLowerBoundTest.java
@@ -43,7 +43,8 @@
.compile()
.inspect(
inspector -> {
- MethodSubject aMethodSubject = inspector.clazz(A.class).uniqueMethodWithName("m");
+ MethodSubject aMethodSubject =
+ inspector.clazz(A.class).uniqueMethodWithOriginalName("m");
assertThat(aMethodSubject, isPresent());
assertTrue(
aMethodSubject
@@ -55,7 +56,8 @@
.anyMatch(instruction -> instruction.isConstString("A: Null")));
// TODO(b/190154391): B.m() is always called with non-null.
- MethodSubject bMethodSubject = inspector.clazz(B.class).uniqueMethodWithName("m");
+ MethodSubject bMethodSubject =
+ inspector.clazz(B.class).uniqueMethodWithOriginalName("m");
assertThat(bMethodSubject, isPresent());
assertTrue(
bMethodSubject
@@ -67,7 +69,8 @@
.anyMatch(instruction -> instruction.isConstString("B: Null")));
// TODO(b/190154391): C.m() is always called with null.
- MethodSubject cMethodSubject = inspector.clazz(C.class).uniqueMethodWithName("m");
+ MethodSubject cMethodSubject =
+ inspector.clazz(C.class).uniqueMethodWithOriginalName("m");
assertThat(cMethodSubject, isPresent());
assertTrue(
cMethodSubject
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
index 20b82f0..cef5521 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CheckNotZeroMethodWithArgumentRemovalTest.java
@@ -48,7 +48,7 @@
assertThat(mainClassSubject, isPresent());
MethodSubject checkNotNullSubject =
- mainClassSubject.uniqueMethodWithName("checkNotNull");
+ mainClassSubject.uniqueMethodWithOriginalName("checkNotNull");
assertThat(checkNotNullSubject, isPresent());
assertEquals(1, checkNotNullSubject.getProgramMethod().getReference().getArity());
})
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
index a728f8c..023b012 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/CompanionConstructorShakingTest.java
@@ -51,7 +51,7 @@
assertThat(hostClassSubject, isPresent());
assertEquals(1, hostClassSubject.allMethods().size());
assertThat(hostClassSubject.clinit(), isAbsent());
- assertThat(hostClassSubject.uniqueMethodWithName("keepHost"), isPresent());
+ assertThat(hostClassSubject.uniqueMethodWithOriginalName("keepHost"), isPresent());
ClassSubject companionClassSubject = inspector.clazz(Host.Companion.class);
assertThat(companionClassSubject, isPresent());
@@ -59,7 +59,7 @@
assertThat(companionClassSubject.init(), isAbsent());
MethodSubject greetMethodSubject =
- companionClassSubject.uniqueMethodWithName("greet");
+ companionClassSubject.uniqueMethodWithOriginalName("greet");
assertThat(greetMethodSubject, isStatic());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
index 3e410db..d1f817a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantReturnAfterArgumentPropagationTest.java
@@ -47,7 +47,7 @@
assertThat(mainClassSubject, isPresent());
MethodSubject identityMethodSubject =
- mainClassSubject.uniqueMethodWithName("identity");
+ mainClassSubject.uniqueMethodWithOriginalName("identity");
assertThat(identityMethodSubject, isPresent());
assertTrue(identityMethodSubject.getProgramMethod().getParameters().isEmpty());
assertTrue(identityMethodSubject.getProgramMethod().getReturnType().isVoidType());
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
index 562c3b5..23b1aa9 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ConstantUnboxedEnumArgumentTest.java
@@ -56,7 +56,8 @@
.streamInstructions()
.noneMatch(InstructionSubject::isStaticGet));
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertEquals(0, testMethodSubject.getProgramMethod().getReference().getArity());
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
index 86ab638..dc9b490 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/EffectivelyFinalCompanionMethodsTest.java
@@ -53,10 +53,10 @@
ClassSubject companionClassSubject = inspector.clazz(Host.Companion.class);
assertThat(companionClassSubject, isPresent());
assertEquals(4, companionClassSubject.allMethods().size());
- assertThat(companionClassSubject.uniqueMethodWithName("foo"), isStatic());
- assertThat(companionClassSubject.uniqueMethodWithName("bar"), isStatic());
- assertThat(companionClassSubject.uniqueMethodWithName("baz"), isStatic());
- assertThat(companionClassSubject.uniqueMethodWithName("qux"), isStatic());
+ assertThat(companionClassSubject.uniqueMethodWithOriginalName("foo"), isStatic());
+ assertThat(companionClassSubject.uniqueMethodWithOriginalName("bar"), isStatic());
+ assertThat(companionClassSubject.uniqueMethodWithOriginalName("baz"), isStatic());
+ assertThat(companionClassSubject.uniqueMethodWithOriginalName("qux"), isStatic());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Foo!", "Bar!", "Baz!", "Qux!", "Baz!");
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
index 65c3ce8..7daf43b 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MixedArgumentRemovalAndEnumUnboxingTest.java
@@ -56,7 +56,8 @@
.streamInstructions()
.noneMatch(InstructionSubject::isConstNull));
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertEquals(2, testMethodSubject.getProgramMethod().getReference().getArity());
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
index 0df2eff..0e32f15 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/MonomorphicMethodWithUnusedReturnValueTest.java
@@ -45,7 +45,7 @@
inspector -> {
// The test() method has been changed to have return type void.
MethodSubject testMethodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("test");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertTrue(testMethodSubject.getProgramMethod().getReturnType().isVoidType());
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
index bca23cb..25af8f6 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/NullableCompanionConstructorShakingTest.java
@@ -49,7 +49,7 @@
.inspect(
inspector -> {
MethodSubject companionMethodSubject =
- inspector.clazz(Host.Companion.class).uniqueMethodWithName("greet");
+ inspector.clazz(Host.Companion.class).uniqueMethodWithOriginalName("greet");
assertThat(companionMethodSubject, isStatic());
MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
index 42d8535..10324b8 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ParameterTypeStrengtheningTest.java
@@ -57,14 +57,16 @@
assertThat(bClassSubject, isPresent());
// Method testA(I) should be rewritten to testA(A).
- MethodSubject testAMethodSubject = mainClassSubject.uniqueMethodWithName("testA");
+ MethodSubject testAMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("testA");
assertThat(testAMethodSubject, isPresent());
assertEquals(
aClassSubject.getFinalName(),
testAMethodSubject.getProgramMethod().getParameter(0).getTypeName());
// Method testB(I) should be rewritten to testB(B).
- MethodSubject testBMethodSubject = mainClassSubject.uniqueMethodWithName("testB");
+ MethodSubject testBMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("testB");
assertThat(testBMethodSubject, isPresent());
assertEquals(
bClassSubject.getFinalName(),
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
index fcf44bb..b38703a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/PolymorphicMethodWithUnusedReturnValueTest.java
@@ -47,7 +47,8 @@
inspector -> {
// The test() methods have been changed to have return type void.
for (Class<?> clazz : new Class<?>[] {A.class, B.class}) {
- MethodSubject testMethodSubject = inspector.clazz(clazz).uniqueMethodWithName("m");
+ MethodSubject testMethodSubject =
+ inspector.clazz(clazz).uniqueMethodWithOriginalName("m");
assertThat(testMethodSubject, isPresent());
assertTrue(testMethodSubject.getProgramMethod().getReturnType().isVoidType());
}
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
index b1faa74..d8d8797 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/ReturnTypeStrengtheningTest.java
@@ -56,14 +56,15 @@
assertThat(aClassSubject, isPresent());
// Return type of get() should be strengthened to A.
- MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithName("get");
+ MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("get");
assertThat(getMethodSubject, isPresent());
assertEquals(
aClassSubject.getFinalName(),
getMethodSubject.getProgramMethod().getReturnType().getTypeName());
// Method consume(I) should be rewritten to consume(A).
- MethodSubject testBMethodSubject = mainClassSubject.uniqueMethodWithName("consume");
+ MethodSubject testBMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("consume");
assertThat(testBMethodSubject, isPresent());
assertEquals(
aClassSubject.getFinalName(),
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
index cee9ab5..e6e00cb 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentTest.java
@@ -50,13 +50,14 @@
assertThat(mainClassSubject, isPresent());
// The test() method has been optimized.
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertEquals(0, testMethodSubject.getProgramMethod().getParameters().size());
assertTrue(
testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
- assertThat(mainClassSubject.uniqueMethodWithName("dead"), isAbsent());
+ assertThat(mainClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Hello", "Hello", "Hello");
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
index 1764b30..86a584a 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/StaticMethodWithConstantArgumentThroughCallChainTest.java
@@ -51,14 +51,15 @@
// The test1(), test2(), and test3() methods have been optimized.
for (int i = 1; i <= 3; i++) {
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test" + i);
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test" + i);
assertThat(testMethodSubject, isPresent());
assertEquals(0, testMethodSubject.getProgramMethod().getParameters().size());
assertTrue(
testMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
}
- assertThat(mainClassSubject.uniqueMethodWithName("dead"), isAbsent());
+ assertThat(mainClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
index dd93e33..4e857f5 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UnboxedEnumUserInMethodWithConstantArgumentTest.java
@@ -56,7 +56,8 @@
.streamInstructions()
.noneMatch(InstructionSubject::isConstNumber));
- MethodSubject testMethodSubject = mainClassSubject.uniqueMethodWithName("test");
+ MethodSubject testMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("test");
assertThat(testMethodSubject, isPresent());
assertEquals(0, testMethodSubject.getProgramMethod().getReference().getArity());
})
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
index 993ca6b..a756ee3 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsArgumentPropagationToResolvedMethodTest.java
@@ -53,7 +53,7 @@
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithName("m");
+ MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
assertThat(aMethodSubject, isPresent());
assertEquals(0, aMethodSubject.getProgramMethod().getReference().getArity());
assertTrue(
@@ -63,7 +63,8 @@
ClassSubject aSub1ClassSubject = inspector.clazz(ASub1.class);
assertThat(aSub1ClassSubject, isPresent());
- MethodSubject aSub1MethodSubject = aSub1ClassSubject.uniqueMethodWithName("m");
+ MethodSubject aSub1MethodSubject =
+ aSub1ClassSubject.uniqueMethodWithOriginalName("m");
assertThat(aSub1MethodSubject, isPresent());
assertEquals(0, aSub1MethodSubject.getProgramMethod().getReference().getArity());
assertTrue(
@@ -74,7 +75,7 @@
ClassSubject aSub2Sub1ClassSubject = inspector.clazz(ASub2Sub1.class);
assertThat(aSub2Sub1ClassSubject, isPresent());
MethodSubject aSub2Sub1MethodSubject =
- aSub2Sub1ClassSubject.uniqueMethodWithName("m");
+ aSub2Sub1ClassSubject.uniqueMethodWithOriginalName("m");
assertThat(aSub2Sub1MethodSubject, isPresent());
assertEquals(0, aSub2Sub1MethodSubject.getProgramMethod().getReference().getArity());
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
index 25ce6a4..44b319b 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/UpwardsInterfacePropagationToUnrelatedMethodTest.java
@@ -46,7 +46,8 @@
.compile()
.inspect(
inspector -> {
- MethodSubject aMethodSubject = inspector.clazz(A.class).uniqueMethodWithName("m");
+ MethodSubject aMethodSubject =
+ inspector.clazz(A.class).uniqueMethodWithOriginalName("m");
assertThat(aMethodSubject, isPresent());
assertTrue(
aMethodSubject
@@ -57,7 +58,8 @@
.streamInstructions()
.anyMatch(instruction -> instruction.isConstString("A: Null")));
- MethodSubject b2MethodSubject = inspector.clazz(B2.class).uniqueMethodWithName("m");
+ MethodSubject b2MethodSubject =
+ inspector.clazz(B2.class).uniqueMethodWithOriginalName("m");
assertThat(b2MethodSubject, isPresent());
assertTrue(
b2MethodSubject
@@ -68,7 +70,8 @@
.streamInstructions()
.noneMatch(instruction -> instruction.isConstString("B2: Null")));
- MethodSubject b3MethodSubject = inspector.clazz(B3.class).uniqueMethodWithName("m");
+ MethodSubject b3MethodSubject =
+ inspector.clazz(B3.class).uniqueMethodWithOriginalName("m");
assertThat(b3MethodSubject, isPresent());
assertTrue(
b3MethodSubject
diff --git a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
index e226a85..b59861c 100644
--- a/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/argumentpropagation/VirtualMethodWithConstantArgumentThroughSiblingInterfaceMethodTest.java
@@ -46,7 +46,7 @@
for (Class<?> clazz : new Class[] {A.class, C.class}) {
ClassSubject aClassSubject = inspector.clazz(clazz);
assertThat(aClassSubject, isPresent());
- MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithName("m");
+ MethodSubject aMethodSubject = aClassSubject.uniqueMethodWithOriginalName("m");
assertThat(aMethodSubject, isPresent());
assertTrue(aMethodSubject.streamInstructions().noneMatch(InstructionSubject::isIf));
}
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
index 84ee636..b9b9866 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeKeptMethodTest.java
@@ -43,7 +43,8 @@
ClassSubject aClassSubject = inspector.clazz(Main.class);
assertThat(aClassSubject, isPresent());
assertThat(
- aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+ aClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), not(isFinal())));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Main.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
index 115b180..5452c48 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodTest.java
@@ -47,7 +47,8 @@
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+ assertThat(
+ aClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
index d134ecb..eb04b78 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualMethodWithSiblingTest.java
@@ -49,11 +49,13 @@
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
assertThat(
- iClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+ iClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), not(isFinal())));
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+ assertThat(
+ aClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()", "C.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
index dd316ac..a91566e 100644
--- a/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/finalize/FinalizeVirtualOverrideTest.java
@@ -49,16 +49,19 @@
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
assertThat(
- aClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+ aClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), not(isFinal())));
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
assertThat(
- bClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), not(isFinal())));
+ bClassSubject.uniqueMethodWithOriginalName("m"),
+ allOf(isPresent(), not(isFinal())));
ClassSubject cClassSubject = inspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- assertThat(cClassSubject.uniqueMethodWithName("m"), allOf(isPresent(), isFinal()));
+ assertThat(
+ cClassSubject.uniqueMethodWithOriginalName("m"), allOf(isPresent(), isFinal()));
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A.m()", "B.m()", "C.m()");
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
index 12d62c9..e90481a 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptMethodTest.java
@@ -50,13 +50,13 @@
TypeSubject bTypeSubject = inspector.clazz(B.class).asTypeSubject();
MethodSubject fooMethodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("foo");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
for (String methodName : new String[] {"bar", "baz"}) {
MethodSubject methodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName(methodName);
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
assertThat(methodSubject, hasParameters(bTypeSubject, aTypeSubject));
}
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
index 3b8abab..21723d9 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithKeptVirtualMethodTest.java
@@ -55,12 +55,13 @@
TypeSubject bTypeSubject = bClassSubject.asTypeSubject();
// A.foo(B, A) is kept.
- MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
// B.foo(B, A) overrides kept method.
- MethodSubject otherFooMethodSubject = bClassSubject.uniqueMethodWithName("foo");
+ MethodSubject otherFooMethodSubject =
+ bClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(otherFooMethodSubject, isPresent());
assertThat(otherFooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
})
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
index 1e6a4e5..1383fef 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithLibraryOverrideTest.java
@@ -49,12 +49,12 @@
TypeSubject bTypeSubject = inspector.getTypeSubject(B.class.getTypeName());
MethodSubject fooMethodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("foo");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
MethodSubject libraryOverrideMethodSubject =
- inspector.clazz(Program.class).uniqueMethodWithName("m");
+ inspector.clazz(Program.class).uniqueMethodWithOriginalName("m");
assertThat(libraryOverrideMethodSubject, isPresent());
assertThat(libraryOverrideMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
})
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
index e4507b5..2e5098b 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithParameterAnnotationsTest.java
@@ -61,7 +61,7 @@
TypeSubject barTypeSubject = inspector.clazz(Bar.class).asTypeSubject();
// Main.bar() has parameter annotations [@Bar, @Foo].
- MethodSubject barMethodSubject = mainClassSubject.uniqueMethodWithName("bar");
+ MethodSubject barMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(barMethodSubject, isPresent());
assertThat(barMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
assertThat(
@@ -70,7 +70,7 @@
ImmutableList.of(barTypeSubject), ImmutableList.of(fooTypeSubject)));
// Main.baz() has parameter annotations [, @Foo].
- MethodSubject bazMethodSubject = mainClassSubject.uniqueMethodWithName("baz");
+ MethodSubject bazMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("baz");
assertThat(bazMethodSubject, isPresent());
assertThat(bazMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
assertThat(
@@ -79,7 +79,7 @@
ImmutableList.of(), ImmutableList.of(fooTypeSubject)));
// Main.qux() has parameter annotations [@Foo, ].
- MethodSubject quxMethodSubject = mainClassSubject.uniqueMethodWithName("qux");
+ MethodSubject quxMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("qux");
assertThat(quxMethodSubject, isPresent());
assertThat(quxMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
assertThat(
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
index de0dfe3..ba776e4 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithVirtualMethodCollisionTest.java
@@ -55,13 +55,14 @@
TypeSubject aTypeSubject = aClassSubject.asTypeSubject();
TypeSubject bTypeSubject = bClassSubject.asTypeSubject();
- MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = aClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertThat(fooMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
// TODO(b/173398086): Consider rewriting B.foo(B, A) to B.foo(A, B, C) instead of
// B.foo$1(A, B).
- MethodSubject otherFooMethodSubject = bClassSubject.uniqueMethodWithName("foo$1");
+ MethodSubject otherFooMethodSubject =
+ bClassSubject.uniqueMethodWithOriginalName("foo$1");
assertThat(otherFooMethodSubject, isPresent());
assertThat(otherFooMethodSubject, hasParameters(aTypeSubject, bTypeSubject));
})
diff --git a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
index dcde130..546c7ce 100644
--- a/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/proto/ProtoNormalizationWithoutSharingTest.java
@@ -48,7 +48,7 @@
// Should not be normalized as there is no sharing of protos.
MethodSubject fooMethodSubject =
- inspector.clazz(Main.class).uniqueMethodWithName("foo");
+ inspector.clazz(Main.class).uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertThat(fooMethodSubject, hasParameters(bTypeSubject, aTypeSubject));
})
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
index 15ed09c..598101f 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
@@ -74,10 +74,10 @@
ClassSubject barClassSubject = inspector.clazz(Bar.class);
assertThat(barClassSubject, isPresentAndRenamed());
- MethodSubject helloMethodSubject = barClassSubject.uniqueMethodWithName("hello");
+ MethodSubject helloMethodSubject = barClassSubject.uniqueMethodWithOriginalName("hello");
assertThat(helloMethodSubject, isPresentAndRenamed());
- MethodSubject worldMethodSubject = barClassSubject.uniqueMethodWithName("world");
+ MethodSubject worldMethodSubject = barClassSubject.uniqueMethodWithOriginalName("world");
assertThat(worldMethodSubject, isPresentAndRenamed());
assertTrue(residualArtProfileConsumer.finished);
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
index 80bb288..ff9003a 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
@@ -68,7 +68,7 @@
ClassSubject greeterClassSubject = inspector.clazz(Greeter.class);
assertThat(greeterClassSubject, isPresentAndRenamed());
- MethodSubject greetMethodSubject = greeterClassSubject.uniqueMethodWithName("greet");
+ MethodSubject greetMethodSubject = greeterClassSubject.uniqueMethodWithOriginalName("greet");
assertThat(greetMethodSubject, isPresentAndRenamed());
assertTrue(residualArtProfileConsumer.finished);
diff --git a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
index da88bc6..f93737b 100644
--- a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
@@ -75,7 +75,7 @@
assertThat(streamClassSubject, isPresentAndNotRenamed());
MethodSubject forEachMethodSubject =
- streamClassSubject.uniqueMethodWithName("forEach");
+ streamClassSubject.uniqueMethodWithOriginalName("forEach");
assertThat(
forEachMethodSubject,
isPresentAndRenamed(
diff --git a/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java b/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
index 879786b..d2275df 100644
--- a/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/configuration/ProguardRuleWithEllipsisForReturnTypeTest.java
@@ -66,8 +66,8 @@
private void inspect(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(clazz);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueFieldWithName("unused"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("main"), isPresent());
+ assertThat(classSubject.uniqueFieldWithOriginalName("unused"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("main"), isPresent());
}
}
diff --git a/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java b/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
index 063976a..e6644ad 100644
--- a/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/rules/ProguardMatchAllRuleWithPrefixTest.java
@@ -32,10 +32,10 @@
ClassSubject classSubject = inspector.clazz(TestClass.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("methodA"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("methodB"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("methodC"), isPresent());
- assertThat(classSubject.uniqueMethodWithName("methodD"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("methodA"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("methodB"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("methodC"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("methodD"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java b/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
index 78694ea..aba69ff 100644
--- a/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
+++ b/src/test/java/com/android/tools/r8/regress/b142682636/Regress142682636Runner.java
@@ -45,10 +45,10 @@
.inspector();
ClassSubject clazz = inspector.clazz(testClass);
assertThat(clazz, isPresent());
- MethodSubject foo = clazz.uniqueMethodWithName("foo");
+ MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
checkNoMoveWide(foo);
- MethodSubject bar = clazz.uniqueMethodWithName("bar");
+ MethodSubject bar = clazz.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresent());
checkNoMoveWide(bar);
}
diff --git a/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java b/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
index fa3661e..6db35da 100644
--- a/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
+++ b/src/test/java/com/android/tools/r8/regress/b147865212/Regress147865212.java
@@ -50,7 +50,7 @@
.inspector();
ClassSubject clazz = inspector.clazz("FlafKt");
assertTrue(clazz.isPresent());
- MethodSubject method = clazz.uniqueMethodWithName("box");
+ MethodSubject method = clazz.uniqueMethodWithOriginalName("box");
assertTrue(method.isPresent());
return method;
}
diff --git a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
index 41d6a49..47c33fb 100644
--- a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
@@ -68,13 +68,14 @@
private void checkDeadCodeThrowInTryRange(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- MethodSubject method = classSubject.uniqueMethodWithName("synchronizedMethod");
+ MethodSubject method = classSubject.uniqueMethodWithOriginalName("synchronizedMethod");
assertThat(method, isPresent());
// Ensure that the "throwNpe" method remains and that it was not inlined by checking that no
// allocations of NullPointerException are in the method.
assertTrue(method.streamInstructions().noneMatch(InstructionSubject::isNewInstance));
- assertThat(inspector.clazz(TestClass.class).uniqueMethodWithName("throwNpe"), isPresent());
+ assertThat(
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("throwNpe"), isPresent());
// Source has 2 catch ranges:
// 1st try catch is the source range, 2nd is the compiler inserted catch over monitor-exit.
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
index 23a5047..38b94ee 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageDebugMinificationTest.java
@@ -66,7 +66,7 @@
inspector -> {
ClassSubject mainClass = inspector.clazz(Main.class);
assertThat(mainClass, isPresentAndNotRenamed());
- MethodSubject main = mainClass.uniqueMethodWithName("main");
+ MethodSubject main = mainClass.uniqueMethodWithOriginalName("main");
assertThat(main, isPresentAndNotRenamed());
ClassSubject aClass = inspector.clazz(A.class);
assertThat(aClass, isPresentAndNotRenamed());
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java
new file mode 100644
index 0000000..a49759f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageKeepClassMembersTest.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.repackage;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RepackageKeepClassMembersTest extends RepackageTestBase {
+
+ public RepackageKeepClassMembersTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ super(flattenPackageHierarchyOrRepackageClasses, parameters);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .setMinApi(parameters.getApiLevel())
+ .apply(this::configureRepackaging)
+ .addKeepRules(
+ "-keepclassmembers class * extends " + typeName(Base.class) + " { <fields>; }")
+ .addKeepMainRule(Main.class)
+ .enableNeverClassInliningAnnotations()
+ .enableInliningAnnotations()
+ .run(parameters.getRuntime(), Main.class, typeName(Sub.class))
+ .inspect(this::inspect)
+ // TODOD(b/250671873): Should not repackage class.
+ .assertSuccessWithOutputLines("Could not find " + typeName(Sub.class));
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Sub.class);
+ assertThat(clazz, isPresent());
+ // TODOD(b/250671873): Should not repackage class.
+ assertThat(Sub.class, isRepackaged(inspector));
+ assertThat(clazz.uniqueFieldWithOriginalName("hashCodeCache"), isPresentAndNotRenamed());
+ assertThat(clazz.uniqueMethodWithOriginalName("calculateHashCode"), isPresentAndRenamed());
+ }
+
+ public static class Base {}
+
+ @NeverClassInline
+ public static class Sub extends Base {
+
+ public int hashCodeCache;
+
+ @NeverInline
+ public int calculateHashCode() {
+ if (hashCodeCache != -1) {
+ return hashCodeCache;
+ }
+ hashCodeCache = Objects.hash(Sub.class);
+ return hashCodeCache;
+ }
+
+ @Override
+ public int hashCode() {
+ return calculateHashCode();
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ if (System.currentTimeMillis() == 0) {
+ System.out.println(new Sub().hashCode());
+ }
+ try {
+ Class<?> subClass = Class.forName(args[0]);
+ Object subInstance = subClass.getDeclaredConstructor().newInstance();
+ subClass.getMethod("calculateHashCode").invoke(subInstance);
+ System.out.println("Hello World!");
+ } catch (Exception e) {
+ System.out.println("Could not find " + args[0]);
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
new file mode 100644
index 0000000..a208857
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageProtectedInSamePackageTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.repackage;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/** This is a reproduction of b/250671873. */
+@RunWith(Parameterized.class)
+public class RepackageProtectedInSamePackageTest extends RepackageTestBase {
+
+ public RepackageProtectedInSamePackageTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ super(flattenPackageHierarchyOrRepackageClasses, parameters);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .setMinApi(parameters.getApiLevel())
+ .apply(this::configureRepackaging)
+ .addKeepRules(
+ "-keepclassmembers,allowobfuscation class * extends "
+ + typeName(Base.class)
+ + " { <fields>; }")
+ .addKeepMainRule(Main.class)
+ .enableNeverClassInliningAnnotations()
+ .enableInliningAnnotations()
+ .run(parameters.getRuntime(), Main.class)
+ .inspect(this::inspect)
+ .assertSuccessWithOutputLines("Hello World!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ // TODO(b/250671873): We should be able to repackage the Sub class since the only reference
+ // to Sub.class is in the same package and we have allowobfuscation.
+ ClassSubject clazz = inspector.clazz(Sub.class);
+ assertThat(clazz, isPresent());
+ assertThat(Sub.class, isNotRepackaged(inspector));
+ assertThat(clazz.uniqueFieldWithOriginalName("hashCodeCache"), isPresentAndRenamed());
+ assertThat(clazz.uniqueMethodWithOriginalName("calculateHashCode"), isPresentAndRenamed());
+ }
+
+ public static class Base {}
+
+ @NeverClassInline
+ public static class Sub extends Base {
+
+ protected int hashCodeCache;
+
+ @NeverInline
+ protected int calculateHashCode() {
+ if (hashCodeCache != -1) {
+ return hashCodeCache;
+ }
+ hashCodeCache = Objects.hash(Sub.class);
+ return hashCodeCache;
+ }
+
+ @Override
+ public int hashCode() {
+ return calculateHashCode();
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ if (System.currentTimeMillis() == 0) {
+ System.out.println(new Sub().hashCode());
+ }
+ System.out.println("Hello World!");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
index 3db9028..23a5cfd 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithBridgeHoistingTest.java
@@ -54,7 +54,7 @@
private void inspect(CodeInspector inspector) {
ClassSubject greeterBase = inspector.clazz(GreeterBase.class);
assertThat(greeterBase, isPresent());
- assertThat(greeterBase.uniqueMethodWithName("greetBridge"), isPresent());
+ assertThat(greeterBase.uniqueMethodWithOriginalName("greetBridge"), isPresent());
}
public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
index 4f028fb..4f6f672 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
@@ -67,21 +67,22 @@
String clinitFieldName = inspector.getFactory().objectMembers.clinitField.name.toSourceString();
if (enableMemberValuePropagationAnnotations) {
// No $r8$clinit field should have been synthesized since we can use the HELLO field.
- assertThat(repackagedClassSubject.uniqueFieldWithName(clinitFieldName), not(isPresent()));
- assertThat(repackagedClassSubject.uniqueFieldWithName("HELLO"), isPresent());
+ assertThat(
+ repackagedClassSubject.uniqueFieldWithOriginalName(clinitFieldName), not(isPresent()));
+ assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("HELLO"), isPresent());
// Verify that the WORLD field has been removed.
- assertThat(repackagedClassSubject.uniqueFieldWithName("WORLD"), not(isPresent()));
+ assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("WORLD"), not(isPresent()));
// Verify that the class was not repackaged.
assertThat(StaticMemberValuePropagation.class, isNotRepackaged(inspector));
} else {
// Verify that a $r8$clinit field was synthesized.
- assertThat(repackagedClassSubject.uniqueFieldWithName(clinitFieldName), isPresent());
+ assertThat(repackagedClassSubject.uniqueFieldWithOriginalName(clinitFieldName), isPresent());
// Verify that both fields have been removed.
- assertThat(repackagedClassSubject.uniqueFieldWithName("HELLO"), not(isPresent()));
- assertThat(repackagedClassSubject.uniqueFieldWithName("WORLD"), not(isPresent()));
+ assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("HELLO"), not(isPresent()));
+ assertThat(repackagedClassSubject.uniqueFieldWithOriginalName("WORLD"), not(isPresent()));
// Verify that the class was repackaged.
assertThat(StaticMemberValuePropagation.class, isRepackaged(inspector));
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java b/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
index 8edefd8..0b057db 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
@@ -61,8 +61,8 @@
.inspect(
inspector -> {
ClassSubject clazz = inspector.clazz(SingleStaticTargetLookupTest.class);
- MethodSubject main = clazz.uniqueMethodWithName("main");
- MethodSubject staticFoo = clazz.uniqueMethodWithName("staticFoo");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
+ MethodSubject staticFoo = clazz.uniqueMethodWithOriginalName("staticFoo");
assertThat(clazz, isPresent());
assertThat(main, isPresent());
assertEquals(keepFoo, staticFoo.isPresent());
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
index aa827c8..5390779 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessTest.java
@@ -149,7 +149,7 @@
private void assertCallingClassCallsTarget(
Class<?> callerClass, AppView<?> appView, DexMethod target) {
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
- MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+ MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.streamInstructions()
.anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
index 50f4428..79c89e8 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
@@ -132,7 +132,7 @@
private void assertCallingClassCallsTarget(
Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod method) {
CodeInspector inspector = new CodeInspector(appInfo.app());
- MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+ MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.streamInstructions()
.anyMatch(
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
index 1a6485c..dd66e5d5 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessTest.java
@@ -124,7 +124,7 @@
private void assertCallingClassCallsTarget(
Class<?> callerClass, AppView<?> appView, DexMethod target) {
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
- MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+ MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.streamInstructions()
.anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
index 5fddce3..efbbd16 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodAccessWithIntermediateTest.java
@@ -160,7 +160,7 @@
private void assertCallingClassCallsTarget(
Class<?> callerClass, AppView<?> appView, DexMethod target) {
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
- MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+ MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.streamInstructions()
.anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
index 31a8904..e1d4d99 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
@@ -121,7 +121,7 @@
private void assertCallingClassCallsTarget(
Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod target) {
CodeInspector inspector = new CodeInspector(appInfo.app());
- MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
+ MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithOriginalName("foo");
assertTrue(
foo.streamInstructions()
.anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == target));
diff --git a/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java b/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
index 029fc63..e2f71f5 100644
--- a/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
+++ b/src/test/java/com/android/tools/r8/resolution/b123730538/B123730538.java
@@ -81,14 +81,15 @@
}
private void inspect(CodeInspector inspector) {
- MethodSubject foo = inspector.clazz(
- PublicClass.class.getTypeName().replace("PublicClass", "AbstractClass"))
- .uniqueMethodWithName("foo");
+ MethodSubject foo =
+ inspector
+ .clazz(PublicClass.class.getTypeName().replace("PublicClass", "AbstractClass"))
+ .uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
ClassSubject main = inspector.clazz(PublicClassExtender.class);
assertThat(main, isPresent());
- MethodSubject methodSubject = main.uniqueMethodWithName("delegate");
+ MethodSubject methodSubject = main.uniqueMethodWithOriginalName("delegate");
assertThat(methodSubject, isPresent());
methodSubject
diff --git a/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
index 820be96..cb07033 100644
--- a/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
@@ -97,10 +97,14 @@
ClassSubject classSubject = inspector.clazz(Result.class);
assertThat(classSubject, isPresent());
assertThat(
- classSubject.uniqueMethodWithName("methodWhichAccessInstanceMethod"), not(isPresent()));
+ classSubject.uniqueMethodWithOriginalName("methodWhichAccessInstanceMethod"),
+ not(isPresent()));
assertThat(
- classSubject.uniqueMethodWithName("methodWhichAccessInstanceField"), not(isPresent()));
- assertThat(classSubject.uniqueMethodWithName("methodWhichAccessStaticField"), not(isPresent()));
+ classSubject.uniqueMethodWithOriginalName("methodWhichAccessInstanceField"),
+ not(isPresent()));
+ assertThat(
+ classSubject.uniqueMethodWithOriginalName("methodWhichAccessStaticField"),
+ not(isPresent()));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
index 8eb9f47..7f2dac3 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -107,13 +107,14 @@
.assertFailureWithErrorThatMatches(containsString("main"))
.inspectStackTrace(
(stackTrace, codeInspector) -> {
- MethodSubject mainSubject = codeInspector.clazz(MAIN).uniqueMethodWithName("main");
+ MethodSubject mainSubject =
+ codeInspector.clazz(MAIN).uniqueMethodWithOriginalName("main");
LinePosition inlineStack =
LinePosition.stack(
LinePosition.create(
kotlinInspector
.clazz("retrace.InlineFunctionsInSameFileKt")
- .uniqueMethodWithName("foo")
+ .uniqueMethodWithOriginalName("foo")
.asFoundMethodSubject(),
1,
8,
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index e95e5a9..d42b54f 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -74,14 +74,14 @@
private FoundMethodSubject inlineExceptionStatic(CodeInspector kotlinInspector) {
return kotlinInspector
.clazz("retrace.InlineFunctionKt")
- .uniqueMethodWithName("inlineExceptionStatic")
+ .uniqueMethodWithOriginalName("inlineExceptionStatic")
.asFoundMethodSubject();
}
private FoundMethodSubject inlineExceptionInstance(CodeInspector kotlinInspector) {
return kotlinInspector
.clazz("retrace.InlineFunction")
- .uniqueMethodWithName("inlineExceptionInstance")
+ .uniqueMethodWithOriginalName("inlineExceptionInstance")
.asFoundMethodSubject();
}
@@ -115,7 +115,8 @@
.assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
.inspectStackTrace(
(stackTrace, codeInspector) -> {
- MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ MethodSubject mainSubject =
+ codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
LinePosition inlineStack =
LinePosition.stack(
LinePosition.create(
@@ -145,7 +146,8 @@
.assertFailureWithErrorThatMatches(containsString("inlineExceptionInstance"))
.inspectStackTrace(
(stackTrace, codeInspector) -> {
- MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ MethodSubject mainSubject =
+ codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
LinePosition inlineStack =
LinePosition.stack(
LinePosition.create(
@@ -181,7 +183,8 @@
.assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
.inspectStackTrace(
(stackTrace, codeInspector) -> {
- MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ MethodSubject mainSubject =
+ codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
LinePosition inlineStack =
LinePosition.stack(
LinePosition.create(
@@ -213,7 +216,8 @@
.assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
.inspectStackTrace(
(stackTrace, codeInspector) -> {
- MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ MethodSubject mainSubject =
+ codeInspector.clazz(main).uniqueMethodWithOriginalName("main");
LinePosition inlineStack =
LinePosition.stack(
LinePosition.create(
diff --git a/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java b/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java
new file mode 100644
index 0000000..96d52ab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RenamedSignatureClashTest.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RenamedSignatureClashTest extends TestBase {
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ private final ClassReference renamedHolder = Reference.classFromTypeName("A");
+ private final ClassReference originalHolder =
+ Reference.classFromTypeName("com.android.tools.r8.naming.retrace.Main");
+
+ private final String mapping =
+ StringUtils.lines(
+ "# { id: 'com.android.tools.r8.mapping', version: '1.0' }",
+ originalHolder.getTypeName() + " -> " + renamedHolder.getTypeName() + ":",
+ " void some.moved.Method.someMethod(int) -> a",
+ " void methodWithRemovedArgument(int) -> a",
+ " # { id: 'com.android.tools.r8.synthesized' }");
+
+ @Test
+ public void testAmbiguousResult() {
+ Retracer retracer =
+ Retracer.createDefault(
+ ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
+ MethodReference methodReference =
+ Reference.methodFromDescriptor(renamedHolder.getDescriptor(), "a", "(I)V");
+ RetraceMethodResult retraceMethodResult = retracer.retraceMethod(methodReference);
+ assertTrue(retraceMethodResult.isAmbiguous());
+ retraceMethodResult.stream()
+ .forEach(
+ result -> {
+ String method = result.getRetracedMethod().asKnown().getMethodReference().toString();
+ if (method.equals("Lsome/moved/Method;someMethod(I)V")) {
+ assertFalse(result.isCompilerSynthesized());
+ } else {
+ assertEquals(
+ originalHolder.getDescriptor() + "methodWithRemovedArgument(I)V", method);
+ assertTrue(result.isCompilerSynthesized());
+ }
+ });
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java b/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java
new file mode 100644
index 0000000..6817079
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceOutsideLineRangeTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RetraceOutsideLineRangeTest extends TestBase {
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ private final ClassReference someOtherClassOriginal =
+ Reference.classFromTypeName("some.other.Class");
+ private final ClassReference someOtherClassRenamed = Reference.classFromTypeName("a");
+ private final ClassReference someClassOriginal = Reference.classFromTypeName("some.Class");
+ private final ClassReference someClassRenamed = Reference.classFromTypeName("b");
+
+ private final String mapping =
+ someOtherClassOriginal.getTypeName()
+ + " -> "
+ + someOtherClassRenamed.getTypeName()
+ + ":\n"
+ + " void method1():42:42 -> a\n"
+ + someClassOriginal.getTypeName()
+ + " -> "
+ + someClassRenamed.getTypeName()
+ + ":\n"
+ + " 28:28:void foo.bar.inlinee():92:92 -> a\n"
+ + " 1:3:void method2():11:13 -> a\n"
+ + " 4:4:void method2():10:10 -> a\n"
+ + " 5:5:void method2():14 -> a\n";
+
+ @Test
+ public void testNoLine() {
+ Retracer retracer =
+ Retracer.createDefault(
+ ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
+ retraceClassMethodAndPosition(retracer, someClassRenamed, someClassOriginal, 2, 1);
+ retraceClassMethodAndPosition(retracer, someOtherClassRenamed, someOtherClassOriginal, 1, 1);
+ }
+
+ private void retraceClassMethodAndPosition(
+ Retracer retracer,
+ ClassReference renamedClass,
+ ClassReference originalClass,
+ int methodCount,
+ int frameCount) {
+ List<RetraceClassElement> classResult =
+ retracer.retraceClass(renamedClass).stream().collect(Collectors.toList());
+ assertEquals(classResult.size(), 1);
+ RetraceClassElement retraceClassResult = classResult.get(0);
+ assertEquals(originalClass, retraceClassResult.getRetracedClass().getClassReference());
+ RetraceMethodResult retraceMethodResult = retraceClassResult.lookupMethod("a");
+ List<RetraceMethodElement> classMethodResults =
+ retraceMethodResult.stream().collect(Collectors.toList());
+ assertEquals(methodCount, classMethodResults.size());
+ List<RetraceFrameElement> classResultFrames =
+ retraceMethodResult
+ .narrowByPosition(RetraceStackTraceContext.empty(), OptionalInt.of(6))
+ .stream()
+ .collect(Collectors.toList());
+ assertEquals(frameCount, classResultFrames.size());
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java b/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
index 3c4c536..db76685 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceStackTraceFunctionalCompositionTest.java
@@ -11,6 +11,7 @@
import static org.objectweb.asm.Opcodes.INVOKESTATIC;
import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.JdkClassFileProvider;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -35,6 +36,7 @@
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Supplier;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -155,6 +157,7 @@
return rewrittenR8Jar;
}
+ @Ignore("b/251677184: Failing since update to target 11")
@Test
public void testR8RetraceAndComposition() throws Exception {
Path rewrittenR8Jar = getRewrittenR8Jar();
@@ -244,6 +247,7 @@
testForR8(Backend.CF)
.setMode(CompilationMode.RELEASE)
.addProgramFiles(r8Input)
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
.addKeepRuleFiles(MAIN_KEEP)
// TODO(b/241763080): Remove when stable version is default.
.enableExperimentalMapFileVersion()
@@ -262,6 +266,7 @@
testForD8(Backend.CF)
.setMode(CompilationMode.RELEASE)
.addProgramFiles(r8Input)
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
.enableExperimentalMapFileVersion()
// TODO(b/241763080): Enable CF PC test mapping for this compilation.
.addOptionsModification(
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
index d60500f..e4f657f 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
@@ -100,7 +100,7 @@
@Parameters(name = "{0}, external: {1}, verbose: {2}, stream: {3}")
public static Collection<Object[]> data() {
return buildParameters(
- getTestParameters().withCfRuntimes().build(),
+ getTestParameters().withSystemRuntime().build(),
BooleanUtils.values(),
BooleanUtils.values(),
BooleanUtils.values());
@@ -210,7 +210,7 @@
}
@Test
- public void testAmbiguousMissingLine() throws Exception {
+ public void testAmbiguousWithSignatureStackTrace() throws Exception {
runRetraceTest(new AmbiguousWithSignatureStackTrace());
}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
index 793a22d..855f0ac 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiInlineInOutlineTest.java
@@ -105,7 +105,7 @@
.retraceFrame(
context,
OptionalInt.of(27),
- Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+ Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
.stream()
.collect(Collectors.toList());
assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
index c037782..2a9ba94 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInOutlineStackTrace.java
@@ -97,7 +97,7 @@
.retraceFrame(
outlineContext,
OptionalInt.of(28),
- Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+ Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
.stream()
.collect(Collectors.toList());
assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
index 0479f47..0823ff3 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineInlineTest.java
@@ -102,7 +102,7 @@
.retraceFrame(
context,
OptionalInt.of(27),
- Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+ Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
.stream()
.collect(Collectors.toList());
assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
index 93611eb..7a8bdee 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutlineNoInlineTest.java
@@ -104,7 +104,7 @@
.retraceFrame(
context,
OptionalInt.of(27),
- Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+ Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
.stream()
.collect(Collectors.toList());
assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java
deleted file mode 100644
index a3ba721..0000000
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiOutsideLineRangeTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.retrace.api;
-
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.ProguardMapProducer;
-import com.android.tools.r8.retrace.RetraceClassElement;
-import com.android.tools.r8.retrace.RetraceFrameElement;
-import com.android.tools.r8.retrace.RetraceMethodElement;
-import com.android.tools.r8.retrace.RetraceMethodResult;
-import com.android.tools.r8.retrace.RetraceStackTraceContext;
-import com.android.tools.r8.retrace.Retracer;
-import java.util.List;
-import java.util.OptionalInt;
-import java.util.stream.Collectors;
-import org.junit.Test;
-
-public class RetraceApiOutsideLineRangeTest extends RetraceApiTestBase {
-
- public RetraceApiOutsideLineRangeTest(TestParameters parameters) {
- super(parameters);
- }
-
- @Override
- protected Class<? extends RetraceApiBinaryTest> binaryTestClass() {
- return ApiTest.class;
- }
-
- public static class ApiTest implements RetraceApiBinaryTest {
-
- private final ClassReference someOtherClassOriginal =
- Reference.classFromTypeName("some.other.Class");
- private final ClassReference someOtherClassRenamed = Reference.classFromTypeName("a");
- private final ClassReference someClassOriginal = Reference.classFromTypeName("some.Class");
- private final ClassReference someClassRenamed = Reference.classFromTypeName("b");
-
- private final String mapping =
- someOtherClassOriginal.getTypeName()
- + " -> "
- + someOtherClassRenamed.getTypeName()
- + ":\n"
- + " void method1():42:42 -> a\n"
- + someClassOriginal.getTypeName()
- + " -> "
- + someClassRenamed.getTypeName()
- + ":\n"
- + " 1:3:void method2():11:13 -> a\n"
- + " 4:4:void method2():10:10 -> a\n"
- + " 28:28:void foo.bar.inlinee():92:92 -> a\n"
- + " 5:5:void method2():14 -> a\n";
-
- @Test
- public void testNoLine() {
- Retracer retracer =
- Retracer.createDefault(
- ProguardMapProducer.fromString(mapping), new DiagnosticsHandler() {});
- retraceClassMethodAndPosition(retracer, someClassRenamed, someClassOriginal, 2, 0);
- retraceClassMethodAndPosition(retracer, someOtherClassRenamed, someOtherClassOriginal, 1, 1);
- }
-
- private void retraceClassMethodAndPosition(
- Retracer retracer,
- ClassReference renamedClass,
- ClassReference originalClass,
- int methodCount,
- int frameCount) {
- List<RetraceClassElement> classResult =
- retracer.retraceClass(renamedClass).stream().collect(Collectors.toList());
- assertEquals(classResult.size(), 1);
- RetraceClassElement retraceClassResult = classResult.get(0);
- assertEquals(originalClass, retraceClassResult.getRetracedClass().getClassReference());
- RetraceMethodResult retraceMethodResult = retraceClassResult.lookupMethod("a");
- List<RetraceMethodElement> classMethodResults =
- retraceMethodResult.stream().collect(Collectors.toList());
- assertEquals(methodCount, classMethodResults.size());
- List<RetraceFrameElement> classResultFrames =
- retraceMethodResult
- .narrowByPosition(RetraceStackTraceContext.empty(), OptionalInt.of(6))
- .stream()
- .collect(Collectors.toList());
- assertEquals(frameCount, classResultFrames.size());
- }
- }
-}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
index 01a62b5..2eb9482 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiResidualSignatureTest.java
@@ -15,7 +15,10 @@
import com.android.tools.r8.retrace.RetraceFieldElement;
import com.android.tools.r8.retrace.RetraceMethodElement;
import com.android.tools.r8.retrace.Retracer;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
import java.util.stream.Collectors;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -39,11 +42,9 @@
"# { id: 'com.android.tools.r8.mapping', version: 'experimental' }\n"
+ "some.Class -> a:\n"
+ " some.SuperType field -> a\n"
- + " # { id: 'com.android.tools.r8.residualsignature', signature: 'Ljava/lang/Object;'"
- + " }\n"
+ + " # { id:'com.android.tools.r8.residualsignature',signature:'Ljava/lang/Object;' }\n"
+ " some.SubType field -> a\n"
- + " # { id: 'com.android.tools.r8.residualsignature', signature: 'Lsome/SuperType;'"
- + " }\n"
+ + " # { id:'com.android.tools.r8.residualsignature',signature:'Lsome/SuperType;' }\n"
+ " void foo(int, int) -> x\n"
+ " # { id: 'com.android.tools.r8.residualsignature', signature: '(I)V' }\n"
+ " void foo(int) -> x\n"
@@ -63,31 +64,49 @@
.collect(Collectors.toList());
assertEquals(1, fooWithTwoArgs.size());
assertEquals(
- "Lsome/Class;foo(II)V",
- fooWithTwoArgs.get(0).getRetracedMethod().asKnown().getMethodReference().toString());
+ setOf("Lsome/Class;foo(II)V"),
+ fooWithTwoArgs.stream()
+ .map(result -> result.getRetracedMethod().asKnown().getMethodReference().toString())
+ .collect(Collectors.toSet()));
List<RetraceMethodElement> fooWithOneArg =
retracer.retraceMethod(Reference.methodFromDescriptor(aClass, "x", "()V")).stream()
.collect(Collectors.toList());
assertEquals(1, fooWithOneArg.size());
assertEquals(
- "Lsome/Class;foo(I)V",
- fooWithOneArg.get(0).getRetracedMethod().asKnown().getMethodReference().toString());
+ setOf("Lsome/Class;foo(I)V"),
+ fooWithOneArg.stream()
+ .map(result -> result.getRetracedMethod().asKnown().getMethodReference().toString())
+ .collect(Collectors.toSet()));
List<RetraceFieldElement> fieldWithSuperType =
retracer
.retraceField(
Reference.field(aClass, "a", Reference.typeFromTypeName("java.lang.Object")))
.stream()
.collect(Collectors.toList());
- // TODO(b/169953605): Use the residual signature information to prune the result.
- assertEquals(2, fieldWithSuperType.size());
+ assertEquals(1, fieldWithSuperType.size());
+ assertEquals(
+ setOf("Lsome/Class;field:Lsome/SuperType;"),
+ fieldWithSuperType.stream()
+ .map(result -> result.getField().asKnown().getFieldReference().toString())
+ .collect(Collectors.toSet()));
List<RetraceFieldElement> fieldWithSubType =
retracer
.retraceField(
Reference.field(aClass, "a", Reference.typeFromTypeName("some.SuperType")))
.stream()
.collect(Collectors.toList());
- // TODO(b/169953605): Use the residual signature information to prune the result.
- assertEquals(2, fieldWithSubType.size());
+ assertEquals(1, fieldWithSubType.size());
+ assertEquals(
+ setOf("Lsome/Class;field:Lsome/SubType;"),
+ fieldWithSubType.stream()
+ .map(result -> result.getField().asKnown().getFieldReference().toString())
+ .collect(Collectors.toSet()));
+ }
+
+ private Set<Object> setOf(Object... objects) {
+ Set<Object> result = new HashSet<>();
+ Collections.addAll(result, objects);
+ return result;
}
}
}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
index 0c1d0a9..40545a6 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSingleFrameTest.java
@@ -56,7 +56,7 @@
.retraceFrame(
RetraceStackTraceContext.empty(),
OptionalInt.empty(),
- Reference.methodFromDescriptor(renamedClass, "a", "()I"))
+ Reference.methodFromDescriptor(renamedClass, "a", "(I)I"))
.stream()
.collect(Collectors.toList()));
checkResults(
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
index d934a5f..9504609 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedFieldTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.retrace.api;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.TestParameters;
@@ -49,8 +49,7 @@
.flatMap(element -> element.lookupField("a").stream())
.collect(Collectors.toList());
assertEquals(1, fieldResults.size());
- // TODO(b/172014416): Should report if synthesized.
- assertThrows(RuntimeException.class, () -> fieldResults.get(0).isCompilerSynthesized());
+ assertTrue(fieldResults.get(0).isCompilerSynthesized());
}
}
}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
index 39228e2..08e8bd5 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiSynthesizedMethodTest.java
@@ -6,7 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.TestParameters;
@@ -52,8 +52,7 @@
assertEquals(1, methodResults.size());
RetraceMethodElement retraceMethodElement = methodResults.get(0);
assertFalse(retraceMethodElement.isUnknown());
- // TODO(b/172014416): Should report if synthesized.
- assertThrows(RuntimeException.class, () -> methodResults.get(0).isCompilerSynthesized());
+ assertTrue(methodResults.get(0).isCompilerSynthesized());
}
}
}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
index 327be4d..5b20d00 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestCollection.java
@@ -32,7 +32,6 @@
RetraceApiUnknownJsonTest.ApiTest.class,
RetraceApiRewriteFrameInlineNpeTest.ApiTest.class,
RetraceApiAmbiguousOriginalRangeTest.ApiTest.class,
- RetraceApiOutsideLineRangeTest.ApiTest.class,
RetraceApiRewriteFrameInlineNpeResidualTest.ApiTest.class,
RetraceApiOutlineNoInlineTest.ApiTest.class,
RetraceApiOutlineInlineTest.ApiTest.class,
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
index 732c1ce..2f3ec65 100644
--- a/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetracePartitionRoundTripTest.java
@@ -140,7 +140,7 @@
.retraceFrame(
context,
OptionalInt.of(27),
- Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)V"))
+ Reference.methodFromDescriptor(callsiteRenamed, "s", "(I)I"))
.stream()
.collect(Collectors.toList());
assertEquals(1, retraceOutlineCallee.size());
diff --git a/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java b/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
index fa9ca5f..0e340bb 100644
--- a/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
+++ b/src/test/java/com/android/tools/r8/retrace/mappings/FieldsWithSameMinifiedNameMapping.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.retrace.mappings;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.Reference;
@@ -20,7 +20,6 @@
@Override
public String mapping() {
- // TODO(b/169953605): Add enough information to the map to allow precise retracing.
return StringUtils.lines(
"foo.bar.Baz -> foo.bar.Baz:", " java.lang.Object f1 -> a", " java.lang.String f2 -> a");
}
@@ -44,13 +43,12 @@
Reference.classFromTypeName("java.lang.Object"));
RetraceFieldResult result = retracer.retraceField(mappedF1FieldReference);
- // TODO(b/169829306): Result should not be ambigious.
- assertTrue(result.isAmbiguous());
+ assertFalse(result.isAmbiguous());
List<FieldReference> retracedFields =
result.stream()
.map(f -> f.getField().asKnown().getFieldReference())
.collect(Collectors.toList());
- assertEquals(ImmutableList.of(f1FieldReference, f2FieldReference), retracedFields);
+ assertEquals(ImmutableList.of(f1FieldReference), retracedFields);
}
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
index c38c66f..c85fbbe 100644
--- a/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/arrays/ArrayLengthRewriteTest.java
@@ -87,26 +87,26 @@
ClassSubject mainClass = inspector.clazz(Main.class);
assertTrue(mainClass.isPresent());
- MethodSubject primitives = mainClass.uniqueMethodWithName("primitives");
+ MethodSubject primitives = mainClass.uniqueMethodWithOriginalName("primitives");
assertArrayLengthCallCount(primitives, debugMode ? 8 : 0);
- MethodSubject nonNullReferences = mainClass.uniqueMethodWithName("nonNullReferences");
+ MethodSubject nonNullReferences = mainClass.uniqueMethodWithOriginalName("nonNullReferences");
assertArrayLengthCallCount(nonNullReferences, debugMode ? 3 : 0);
// No assertion on nullReference() because it's seen as always throwing an NPE and
// the array-length instruction is removed. The output check validates behavior.
- MethodSubject argument = mainClass.uniqueMethodWithName("argument");
+ MethodSubject argument = mainClass.uniqueMethodWithOriginalName("argument");
assertArrayLengthCallCount(argument, 1);
- MethodSubject phi = mainClass.uniqueMethodWithName("phi");
+ MethodSubject phi = mainClass.uniqueMethodWithOriginalName("phi");
assertArrayLengthCallCount(phi, 1);
// TODO(139489070): these should be rewritten and result in 0 array-length bytecodes
- MethodSubject staticConstants = mainClass.uniqueMethodWithName("staticConstants");
+ MethodSubject staticConstants = mainClass.uniqueMethodWithOriginalName("staticConstants");
assertArrayLengthCallCount(staticConstants, (d8 || debugMode) ? 3 : 0);
- MethodSubject staticNonConstants = mainClass.uniqueMethodWithName("staticNonConstants");
+ MethodSubject staticNonConstants = mainClass.uniqueMethodWithOriginalName("staticNonConstants");
assertArrayLengthCallCount(staticNonConstants, (d8 || debugMode) ? 2 : 0);
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
index c205888..efab8b4 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
@@ -197,13 +197,13 @@
assertEquals(
(isR8 ? 0 : 1),
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.filter(InstructionSubject::isStaticPut)
.count());
assertFalse(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(InstructionSubject::isConstNumber));
} else {
@@ -211,7 +211,7 @@
// for the class kotlin._Assertions.
assertFalse(
subject
- .uniqueMethodWithName("m")
+ .uniqueMethodWithOriginalName("m")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
@@ -229,19 +229,19 @@
assertEquals(
isR8 ? 1 : 2,
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.filter(InstructionSubject::isStaticPut)
.count());
assertTrue(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(instruction -> instruction.isConstNumber(1)));
} else {
assertTrue(
subject
- .uniqueMethodWithName("m")
+ .uniqueMethodWithOriginalName("m")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
@@ -266,18 +266,18 @@
assertEquals(
isR8 ? 1 : 2,
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.filter(InstructionSubject::isStaticPut)
.count());
assertFalse(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(InstructionSubject::isConstNumber));
} else {
assertThat(subject, isPresent());
- MethodSubject clinit = subject.uniqueMethodWithName("<clinit>");
+ MethodSubject clinit = subject.uniqueMethodWithOriginalName("<clinit>");
if (useJvmAssertions) {
assertTrue(clinit.streamInstructions().anyMatch(InstructionSubject::isStaticPut));
} else {
@@ -285,7 +285,7 @@
}
assertTrue(
subject
- .uniqueMethodWithName("m")
+ .uniqueMethodWithOriginalName("m")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
index c9236d4..b677f20 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsCheckerUtils.java
@@ -15,16 +15,16 @@
static void checkAssertionCodeEnabled(ClassSubject subject, String methodName) {
MatcherAssert.assertThat(subject, Matchers.isPresent());
// <clinit> is removed by R8.
- if (subject.uniqueMethodWithName("<clinit>").isPresent()) {
+ if (subject.uniqueMethodWithOriginalName("<clinit>").isPresent()) {
Assert.assertFalse(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(InstructionSubject::isStaticPut));
}
Assert.assertTrue(
subject
- .uniqueMethodWithName(methodName)
+ .uniqueMethodWithOriginalName(methodName)
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
index 9ba3328..2141fea 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
@@ -125,16 +125,16 @@
private void checkAssertionCodeRemoved(ClassSubject subject) {
assertThat(subject, isPresent());
// <clinit> is removed by R8 as it becomes empty.
- if (subject.uniqueMethodWithName("<clinit>").isPresent()) {
+ if (subject.uniqueMethodWithOriginalName("<clinit>").isPresent()) {
assertFalse(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(InstructionSubject::isStaticPut));
}
assertFalse(
subject
- .uniqueMethodWithName("m")
+ .uniqueMethodWithOriginalName("m")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
@@ -152,12 +152,12 @@
assertThat(subject, isPresent());
assertTrue(
subject
- .uniqueMethodWithName("<clinit>")
+ .uniqueMethodWithOriginalName("<clinit>")
.streamInstructions()
.anyMatch(InstructionSubject::isStaticPut));
assertTrue(
subject
- .uniqueMethodWithName("m")
+ .uniqueMethodWithOriginalName("m")
.streamInstructions()
.anyMatch(InstructionSubject::isThrow));
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
index 7fc0289..7cd0420 100644
--- a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
@@ -75,29 +75,30 @@
assertTrue(clazz.isPresent());
if (enableOptimization) {
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("simple"), 1);
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("local"), 1);
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("simple"), 1);
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), 1);
// Even replaced ordinal is concatenated (and gone).
- assertOrdinalReplacedAndGone(clazz.uniqueMethodWithName("multipleUsages"));
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("inlined"), 1);
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("inSwitch"), 11);
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("differentTypeStaticField"), 1);
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), 1);
- assertOrdinalReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), 1);
+ assertOrdinalReplacedAndGone(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), 1);
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("inSwitch"), 11);
+ assertOrdinalReplacedWithConst(
+ clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), 1);
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), 1);
+ assertOrdinalReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonValueStaticField"), 1);
} else {
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("simple"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("local"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("inSwitch"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("simple"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("inSwitch"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
}
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
- assertOrdinalWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
+ assertOrdinalWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
- assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+ assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
}
@Test
@@ -123,28 +124,29 @@
assertTrue(clazz.isPresent());
if (enableOptimization) {
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("simple"), "TWO");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("local"), "TWO");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("multipleUsages"), "1TWO");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("inlined"), "TWO");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("differentTypeStaticField"), "DOWN");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), "TWO");
- assertNameReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), "TWO");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("simple"), "TWO");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), "TWO");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("multipleUsages"), "1TWO");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), "TWO");
+ assertNameReplacedWithConst(
+ clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), "DOWN");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), "TWO");
+ assertNameReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonValueStaticField"), "TWO");
} else {
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("simple"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("local"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("simple"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
}
// TODO(jakew) this should be allowed!
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
- assertNameWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+ assertNameWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
- assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+ assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
}
@Test
@@ -170,33 +172,34 @@
ClassSubject clazz = inspector.clazz(ToStrings.class);
assertTrue(clazz.isPresent());
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("typeToString"));
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("valueWithToString"), "one");
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("valueWithoutToString"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("typeToString"));
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("valueWithToString"), "one");
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("valueWithoutToString"));
if (enableOptimization) {
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("noToString"), "TWO");
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("local"), "TWO");
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("multipleUsages"), "TWO");
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("inlined"), "TWO");
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("nonValueStaticField"), "TWO");
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("noToString"), "TWO");
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("local"), "TWO");
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("multipleUsages"), "TWO");
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("inlined"), "TWO");
assertToStringReplacedWithConst(
- clazz.uniqueMethodWithName("differentTypeStaticField"), "DOWN");
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("nonStaticGet"), "TWO");
+ clazz.uniqueMethodWithOriginalName("nonValueStaticField"), "TWO");
+ assertToStringReplacedWithConst(
+ clazz.uniqueMethodWithOriginalName("differentTypeStaticField"), "DOWN");
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithOriginalName("nonStaticGet"), "TWO");
} else {
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("noToString"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("local"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("multipleUsages"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("inlined"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("nonValueStaticField"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("differentTypeStaticField"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("nonStaticGet"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("noToString"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("local"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("multipleUsages"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("inlined"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonValueStaticField"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("differentTypeStaticField"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("nonStaticGet"));
}
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("libraryType"));
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("phi"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("libraryType"));
+ assertToStringWasNotReplaced(clazz.uniqueMethodWithOriginalName("phi"));
- assertThat(clazz.uniqueMethodWithName("inlined2"), isAbsent());
+ assertThat(clazz.uniqueMethodWithOriginalName("inlined2"), isAbsent());
}
private static void assertOrdinalReplacedWithConst(MethodSubject method, int expectedConst) {
diff --git a/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java b/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
index 26dcb7a..ddbefce 100644
--- a/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
@@ -67,16 +67,16 @@
public void checkSwitchKeys(CodeInspector inspector) {
checkSwitch(
- inspector.clazz(TestClass.class).uniqueMethodWithName("f"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("f"),
parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
checkSwitch(
- inspector.clazz(TestClass.class).uniqueMethodWithName("g"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("g"),
parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
// Debug mode will not rewrite switch statements except when the MAX_INT key is present.
assertEquals(
inspector
.clazz(TestClass.class)
- .uniqueMethodWithName("h")
+ .uniqueMethodWithOriginalName("h")
.streamInstructions()
.filter(InstructionSubject::isSwitch)
.count(),
@@ -85,7 +85,7 @@
&& parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K)));
checkStringSwitch(
- inspector.clazz(TestClass.class).uniqueMethodWithName("s"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("s"),
parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
index 0fce1c4..201971d 100644
--- a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
@@ -55,7 +55,7 @@
assertFalse(classSubject.isAbstract());
// A.m() is also not made abstract in compat mode.
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("m");
assertThat(methodSubject, isPresent());
assertFalse(methodSubject.isAbstract());
@@ -86,7 +86,7 @@
assertTrue(classSubject.isAbstract());
// A.m() is also made abstract in full mode.
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName("m");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.isAbstract());
diff --git a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
index cb750b5..ca0f8d5 100644
--- a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
@@ -55,7 +55,7 @@
ClassSubject classSubject = inspector.clazz(C.class);
assertThat(classSubject, isPresent());
// TODO(b/150445487): Member rebinding will rewrite B::foo to A::foo causing C::foo to remain.
- assertThat(classSubject.uniqueMethodWithName("foo"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("foo"), isPresent());
}
@NoVerticalClassMerging
diff --git a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
index 5fec641..7ccba55 100644
--- a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
@@ -161,7 +161,8 @@
.compile()
.inspect(
inspector ->
- assertThat(inspector.clazz(main.name).uniqueFieldWithName("sField"), isAbsent()));
+ assertThat(
+ inspector.clazz(main.name).uniqueFieldWithOriginalName("sField"), isAbsent()));
}
@Test
@@ -196,7 +197,7 @@
assertThat(emptyClassSubject, isPresent());
assertTrue(emptyClassSubject.allFields().isEmpty());
- MethodSubject fooMethodSubject = emptyClassSubject.uniqueMethodWithName("foo");
+ MethodSubject fooMethodSubject = emptyClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(fooMethodSubject, isPresent());
assertTrue(
fooMethodSubject
@@ -350,7 +351,7 @@
ClassBuilder fieldHolder,
String fieldName,
boolean isR8) {
- FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithName(fieldName);
+ FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithOriginalName(fieldName);
if (isR8) {
assertThat(fld, isPresentAndRenamed());
} else {
@@ -359,7 +360,7 @@
ClassSubject classSubject = inspector.clazz(className);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
+ MethodSubject methodSubject = classSubject.uniqueMethodWithOriginalName(methodName);
assertThat(methodSubject, isPresent());
Iterator<InstructionSubject> it =
methodSubject.iterateInstructions(InstructionSubject::isFieldAccess);
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java b/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
index 5a16cf6..a47a068 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
@@ -70,7 +70,7 @@
assertThat(inspector.clazz(ABSENT_ANNOTATION), not(isPresent()));
assertThat(inspector.clazz(PRESENT_ANNOTATION), isPresent());
ClassSubject clazz = inspector.clazz(CLASS_WITH_ANNOTATED_METHOD);
- MethodSubject method = clazz.uniqueMethodWithName(ANNOTATED_METHOD);
+ MethodSubject method = clazz.uniqueMethodWithOriginalName(ANNOTATED_METHOD);
assertThat(method, isPresent());
}
@@ -125,7 +125,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(CLASS_WITH_ANNOTATED_METHOD);
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName(ANNOTATED_METHOD), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName(ANNOTATED_METHOD), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
index 05cec26..87ef2b8 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
@@ -46,7 +46,8 @@
.compile()
.inspect(
inspector ->
- assertThat(inspector.clazz(Foo.class).uniqueFieldWithName("value"), isPresent()))
+ assertThat(
+ inspector.clazz(Foo.class).uniqueFieldWithOriginalName("value"), isPresent()))
.run(parameters.getRuntime(), Foo.class)
.assertSuccessWithEmptyOutput();
}
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java b/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
index a1f492b..3f24aed 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepNonConstructorsTest.java
@@ -57,7 +57,7 @@
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.uniqueMethodWithName("m"), isPresent());
+ assertThat(aClassSubject.uniqueMethodWithOriginalName("m"), isPresent());
assertEquals(1, aClassSubject.allMethods().size());
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
index 2b2e440..a5704cb 100644
--- a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
@@ -55,7 +55,7 @@
private void checkIsFooPresent(CodeInspector inspector) {
ClassSubject classSubject = inspector.clazz(C.class);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("foo"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
}
@NoVerticalClassMerging
diff --git a/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
index e38943c..0a61b39 100644
--- a/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ParameterTypeTest.java
@@ -147,7 +147,7 @@
} else {
assertThat(superInterface1, isPresentAndRenamed());
}
- MethodSubject foo = superInterface1.uniqueMethodWithName("foo");
+ MethodSubject foo = superInterface1.uniqueMethodWithOriginalName("foo");
assertThat(foo, not(isPresent()));
ClassSubject superInterface2 = inspector.clazz(B112452064SuperInterface2.class);
if (enableVerticalClassMerging) {
@@ -155,7 +155,7 @@
} else {
assertThat(superInterface2, isPresentAndRenamed());
}
- MethodSubject bar = superInterface2.uniqueMethodWithName("bar");
+ MethodSubject bar = superInterface2.uniqueMethodWithOriginalName("bar");
assertThat(bar, not(isPresent()));
ClassSubject subInterface = inspector.clazz(B112452064SubInterface.class);
if (enableUnusedInterfaceRemoval) {
diff --git a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
index 74b7c8a..a5c58ae 100644
--- a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
@@ -78,7 +78,8 @@
.anyMatch(
c -> {
if (c.isSynthesizedJavaLambdaClass()) {
- assertThat(c.uniqueMethodWithName("computeTheFoo"), isPresent());
+ assertThat(
+ c.uniqueMethodWithOriginalName("computeTheFoo"), isPresent());
return true;
}
return false;
diff --git a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
index 3fc3434..9dd9eb6 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
@@ -8,9 +8,11 @@
import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.JdkClassFileProvider;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -35,7 +37,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withCfRuntimes().build();
+ return getTestParameters().withSystemRuntime().build();
}
public PrintConfigurationTest(TestParameters parameters) {
@@ -83,8 +85,10 @@
"-printconfiguration proguard-config-out.txt");
FileUtils.writeTextFile(proguardConfigFile, proguardConfig.trim());
+ assertEquals(TestRuntime.getSystemRuntime(), parameters.getRuntime());
testForExternalR8(Backend.DEX, parameters.getRuntime())
.addProgramClasses(PrintConfigurationTestClass.class)
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
.addKeepRuleFiles(proguardConfigFile)
.compile();
diff --git a/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java b/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
index 27c98f6..7149490 100644
--- a/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/RemoveCallToStaticInitTest.java
@@ -55,7 +55,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(B.class);
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName("foo"), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName("foo"), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
index 3cf998b..f12c211 100644
--- a/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/UninitializedInstantiatedTypeShakingTest.java
@@ -50,7 +50,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject.init(), not(isPresent()));
// TODO(b/132669230): A.method() should be pruned.
- assertThat(classSubject.uniqueMethodWithName("method"), isPresent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("method"), isPresent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
index ac46b3f..2fc2284 100644
--- a/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/addconfigurationdebugging/ConfigurationDebuggingTest.java
@@ -167,10 +167,10 @@
ClassSubject testClass = inspector.clazz(TestClass.class);
assertThat(testClass, isPresent());
- MethodSubject foo = testClass.uniqueMethodWithName("foo");
+ MethodSubject foo = testClass.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
assertTrue(hasThrow(foo));
- MethodSubject bar = testClass.uniqueMethodWithName("bar");
+ MethodSubject bar = testClass.uniqueMethodWithOriginalName("bar");
assertThat(bar, isPresent());
assertTrue(hasThrow(bar));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
index abb4c9f..2217ace 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -90,14 +90,14 @@
ClassSubject bClass = inspector.clazz(B.class);
// The class constants will force A and B to be retained, but not the methods.
assertThat(bClass, isPresentAndRenamed());
- assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
- assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+ assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+ assertThat(bClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
assertThat(aClass, isPresentAndRenamed());
// The dependent rule with soft-pinning of bar never causes A::bar to be retained
// regardless of A and A::foo being retained.
- assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
- MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+ assertThat(aClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
+ MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
if (allowOptimization) {
assertThat(aFoo, not(isPresent()));
} else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
index 5c99afd..4beb2fe 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/ConditionalKeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -77,7 +77,8 @@
assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
- MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+ MethodSubject getMethodSubject =
+ companionClassSubject.uniqueMethodWithOriginalName("get");
if (allowOptimization) {
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
index e6e8b69..4bd9bfd 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingCompatibilityTest.java
@@ -93,8 +93,8 @@
// The class constants will force A and B to be retained, but not the foo methods.
assertThat(bClass, isPresentAndRenamed(allowObfuscation));
assertThat(aClass, isPresentAndRenamed(allowObfuscation));
- assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
- MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+ assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+ MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
if (allowOptimization) {
assertThat(aFoo, not(isPresent()));
} else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
index 44abb34..905951a 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepAllowShrinkingIncludeDescriptorClassesCompatibilityTest.java
@@ -62,8 +62,9 @@
assertThat(inspector.clazz(TestClass.class), isPresent());
ClassSubject softPinnedClass = inspector.clazz(SoftPinned.class);
- assertThat(softPinnedClass.uniqueMethodWithName("used"), isPresentAndNotRenamed());
- assertThat(softPinnedClass.uniqueMethodWithName("unused"), not(isPresent()));
+ assertThat(
+ softPinnedClass.uniqueMethodWithOriginalName("used"), isPresentAndNotRenamed());
+ assertThat(softPinnedClass.uniqueMethodWithOriginalName("unused"), not(isPresent()));
// SoftPinned.used(A) remains thus A must be present and not renamed.
assertThat(inspector.clazz(A.class), isPresentAndNotRenamed());
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
index e0e151a..0d73c09 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassFieldsAllowShrinkingCompatibilityTest.java
@@ -90,10 +90,10 @@
assertThat(aClass, isPresentAndRenamed());
assertThat(bClass, isPresentAndRenamed());
- FieldSubject aFoo = aClass.uniqueFieldWithName("foo");
- FieldSubject aBar = aClass.uniqueFieldWithName("bar");
- FieldSubject bFoo = bClass.uniqueFieldWithName("foo");
- FieldSubject bBar = bClass.uniqueFieldWithName("bar");
+ FieldSubject aFoo = aClass.uniqueFieldWithOriginalName("foo");
+ FieldSubject aBar = aClass.uniqueFieldWithOriginalName("bar");
+ FieldSubject bFoo = bClass.uniqueFieldWithOriginalName("foo");
+ FieldSubject bBar = bClass.uniqueFieldWithOriginalName("bar");
if (allowOptimization) {
// PG fails to optimize out the referenced field.
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
index 5305ced..ff2da06 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepClassMethodsAllowShrinkingCompatibilityTest.java
@@ -92,14 +92,14 @@
ClassSubject bClass = inspector.clazz(B.class);
// The class constants will force A and B to be retained, but not the methods.
assertThat(bClass, isPresentAndRenamed());
- assertThat(bClass.uniqueMethodWithName("foo"), not(isPresent()));
- assertThat(bClass.uniqueMethodWithName("bar"), not(isPresent()));
+ assertThat(bClass.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+ assertThat(bClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
assertThat(aClass, isPresentAndRenamed());
// The dependent rule with soft-pinning of bar never causes A::bar to be retained
// regardless of A and A::foo being retained.
- assertThat(aClass.uniqueMethodWithName("bar"), not(isPresent()));
- MethodSubject aFoo = aClass.uniqueMethodWithName("foo");
+ assertThat(aClass.uniqueMethodWithOriginalName("bar"), not(isPresent()));
+ MethodSubject aFoo = aClass.uniqueMethodWithOriginalName("foo");
if (allowOptimization) {
assertThat(aFoo, not(isPresent()));
} else {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
index 4266e57..4d62baf 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepMethodNameCompatibilityTest.java
@@ -54,7 +54,8 @@
.inspect(
inspector ->
assertThat(
- inspector.clazz(TestClass.class).uniqueMethodWithName("test"), isPresent()))
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("test"),
+ isPresent()))
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines("foo");
}
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
index 2322f85..6f8cf2a 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticFieldAllowShrinkingCompatibilityTest.java
@@ -74,7 +74,7 @@
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
ClassSubject companionClassSubject = inspector.clazz(Companion.class);
- FieldSubject xFieldSubject = companionClassSubject.uniqueFieldWithName("x");
+ FieldSubject xFieldSubject = companionClassSubject.uniqueFieldWithOriginalName("x");
// PG fails to optimize fields regardless of keep flags.
if (allowOptimization && shrinker.isR8()) {
diff --git a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
index 9dbdbb4..043e0e9 100644
--- a/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/allowshrinking/KeepStaticMethodAllowShrinkingCompatibilityTest.java
@@ -75,7 +75,8 @@
assertThat(companionClassSubject, notIf(isPresent(), allowOptimization));
MethodSubject mainMethodSubject = testClassSubject.mainMethod();
- MethodSubject getMethodSubject = companionClassSubject.uniqueMethodWithName("get");
+ MethodSubject getMethodSubject =
+ companionClassSubject.uniqueMethodWithOriginalName("get");
if (allowOptimization) {
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
index 55556b4..2f5eab9 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnFieldsTest.java
@@ -63,12 +63,12 @@
assertThat(clazz, isPresent());
assertThat(clazz, isPresentAndRenamed());
- FieldSubject field = clazz.uniqueFieldWithName("field");
+ FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
assertThat(field, isPresent());
assertThat(field.annotation(FieldAnnotation.class.getTypeName()), isPresent());
assertThat(inspector.clazz(FieldAnnotationUse.class), isPresentAndRenamed());
- FieldSubject staticField = clazz.uniqueFieldWithName("staticField");
+ FieldSubject staticField = clazz.uniqueFieldWithOriginalName("staticField");
assertThat(staticField, isPresent());
assertThat(
staticField.annotation(StaticFieldAnnotation.class.getTypeName()), isPresent());
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
index 62bcf76..d07689d 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/KeepDisallowAnnotationRemovalAllowOptimizationTest.java
@@ -64,13 +64,14 @@
// The annotation on getNonNull() is kept meanwhile it is subject to other
// optimizations.
- MethodSubject getNonNullSubject = classSubject.uniqueMethodWithName("getNonNull");
+ MethodSubject getNonNullSubject =
+ classSubject.uniqueMethodWithOriginalName("getNonNull");
assertThat(getNonNullSubject, isPresentAndRenamed());
assertThat(getNonNullSubject.annotation(NeverInline.class), isPresent());
// Check that the code has been optimized using the fact that getNonNull() returns a
// non-null value.
- assertThat(classSubject.uniqueMethodWithName("dead"), isAbsent());
+ assertThat(classSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
assertThat(classSubject.mainMethod(), not(containsThrow()));
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
index e78d675..135287e 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
@@ -125,7 +125,7 @@
ClassSubject clazz = inspector.clazz(Foo.class);
assertThat(clazz, isPresent());
assertThat(clazz.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
- MethodSubject foo = clazz.uniqueMethodWithName("foo");
+ MethodSubject foo = clazz.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresent());
assertThat(foo.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
assertFalse(foo.getMethod().parameterAnnotationsList.isEmpty());
@@ -139,7 +139,7 @@
.toSourceString());
assertThat(
clazz
- .uniqueFieldWithName("bar")
+ .uniqueFieldWithOriginalName("bar")
.annotation(LibraryAnnotation.class.getTypeName()),
isPresent());
})
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
index da0b781..6aeec9f 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ProgramAnnotationRemovalTest.java
@@ -77,14 +77,14 @@
assertThat(testClassSubject, isPresent());
MethodSubject methodWithLiveProgramAnnotationSubject =
- testClassSubject.uniqueMethodWithName("methodWithLiveProgramAnnotation");
+ testClassSubject.uniqueMethodWithOriginalName("methodWithLiveProgramAnnotation");
assertThat(methodWithLiveProgramAnnotationSubject, isPresent());
assertEquals(
BooleanUtils.intValue(enableCompatMode),
methodWithLiveProgramAnnotationSubject.getMethod().annotations().size());
MethodSubject methodWithDeadProgramAnnotationSubject =
- testClassSubject.uniqueMethodWithName("methodWithDeadProgramAnnotation");
+ testClassSubject.uniqueMethodWithOriginalName("methodWithDeadProgramAnnotation");
assertThat(methodWithDeadProgramAnnotationSubject, isPresent());
assertEquals(0, methodWithDeadProgramAnnotationSubject.getMethod().annotations().size());
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 852c86f..d0c5bdc 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -113,13 +113,13 @@
.inspector();
ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
assertThat(clazz, isPresentAndNotRenamed());
- MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
assertThat(f1, isPresentAndNotRenamed());
- MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
assertThat(f2, isPresentAndNotRenamed());
- MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
assertThat(f3, isPresentAndNotRenamed());
- MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
assertThat(f4, isPresentAndNotRenamed());
ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -155,13 +155,13 @@
ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
assertThat(clazz, isPresent());
assertEquals(minify, clazz.isRenamed());
- MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
assertThat(f1, isPresentAndNotRenamed());
- MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
assertThat(f2, isPresentAndNotRenamed());
- MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
assertThat(f3, not(isPresent()));
- MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
assertThat(f4, not(isPresent()));
ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -193,13 +193,13 @@
ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
assertThat(clazz, isPresent());
assertEquals(minify, clazz.isRenamed());
- MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
assertThat(f1, isPresentAndNotRenamed());
- MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
assertThat(f2, isPresentAndNotRenamed());
- MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
assertThat(f3, not(isPresent()));
- MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
assertThat(f4, not(isPresent()));
ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
@@ -230,13 +230,13 @@
ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
assertThat(clazz, isPresent());
assertEquals(minify, clazz.isRenamed());
- MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ MethodSubject f1 = clazz.uniqueMethodWithOriginalName("f1");
assertThat(f1, isPresent());
- MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ MethodSubject f2 = clazz.uniqueMethodWithOriginalName("f2");
assertThat(f2, isPresent());
- MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ MethodSubject f3 = clazz.uniqueMethodWithOriginalName("f3");
assertThat(f3, not(isPresent()));
- MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ MethodSubject f4 = clazz.uniqueMethodWithOriginalName("f4");
assertThat(f4, not(isPresent()));
ClassSubject impl = inspector.clazz(IMPL_CLASS_NAME);
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
index 7d2173f..683a18c 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/SerializedNameAlternateTest.java
@@ -120,7 +120,7 @@
EXPECTED_DEFAULT_VALUE_ANNOTATION, EXPECTED_SERIALIZED_ANNOTATION)
.inspect(
codeInspector -> {
- FieldSubject bar = codeInspector.clazz(Foo.class).uniqueFieldWithName("bar");
+ FieldSubject bar = codeInspector.clazz(Foo.class).uniqueFieldWithOriginalName("bar");
AnnotationSubject annotation = bar.annotation(SerializedName.class.getTypeName());
assertThat(annotation, isPresent());
assertEquals(0, annotation.getAnnotation().elements.length);
diff --git a/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java b/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
index a4ba893..ff7cb9e 100644
--- a/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/array/DeadArrayLengthTest.java
@@ -42,15 +42,15 @@
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject nonNull = main.uniqueMethodWithName("clearlyNonNull");
+ MethodSubject nonNull = main.uniqueMethodWithOriginalName("clearlyNonNull");
assertThat(nonNull, isPresent());
assertEquals(0, countArrayLength(nonNull));
- MethodSubject nullable = main.uniqueMethodWithName("isNullable");
+ MethodSubject nullable = main.uniqueMethodWithOriginalName("isNullable");
assertThat(nullable, isPresent());
assertEquals(isR8 ? 0 : 1, countArrayLength(nullable));
- MethodSubject nullCheck = main.uniqueMethodWithName("afterNullCheck");
+ MethodSubject nullCheck = main.uniqueMethodWithOriginalName("afterNullCheck");
assertThat(nullCheck, isPresent());
assertEquals(isR8 ? 0 : 1, countArrayLength(nullCheck));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
index fed4e6d..6419f78 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
@@ -55,11 +55,14 @@
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
- inspectMethod(testClassSubject.uniqueMethodWithName("testModelingOfSideEffects"), false, false);
inspectMethod(
- testClassSubject.uniqueMethodWithName("testModelingOfSideEffectsMaybeNull"), true, false);
+ testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffects"), false, false);
inspectMethod(
- testClassSubject.uniqueMethodWithName("testModelingOfSideEffectsMaybeSubclass"),
+ testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffectsMaybeNull"),
+ true,
+ false);
+ inspectMethod(
+ testClassSubject.uniqueMethodWithOriginalName("testModelingOfSideEffectsMaybeSubclass"),
false,
true);
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
index ad79ff7..0cabc92 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
@@ -69,7 +69,7 @@
mainMethod.streamInstructions().noneMatch(
i -> i.isInvoke() && i.getMethod().name.toString().equals("debug")));
- MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+ MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
assertThat(testInvokeInterface, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
index 41311d2..3fd3987 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
@@ -68,10 +68,10 @@
mainMethod.streamInstructions().noneMatch(
i -> i.isInvoke() && i.getMethod().name.toString().equals("info")));
- MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+ MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
assertThat(testInvokeInterface, not(isPresent()));
- FieldSubject tag = main.uniqueFieldWithName("TAG");
+ FieldSubject tag = main.uniqueFieldWithOriginalName("TAG");
assertThat(tag, not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
index 352a53c..78f813d 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithoutReturnValueTest.java
@@ -84,7 +84,7 @@
private void verifyDebugMethodIsRemoved(CodeInspector inspector) {
ClassSubject main = inspector.clazz(MAIN);
assertThat(main, isPresent());
- MethodSubject debug = main.uniqueMethodWithName("debug");
+ MethodSubject debug = main.uniqueMethodWithOriginalName("debug");
assertThat(debug, not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
index 0caf415..31930b0 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumeValuesMaterializeFieldReadTest.java
@@ -49,7 +49,7 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
- MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithName("get");
+ MethodSubject getMethodSubject = mainClassSubject.uniqueMethodWithOriginalName("get");
assertThat(getMethodSubject, isAbsent());
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
index a6d7d67..4455ff1 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/AssumevaluesWithMultipleTargetsTest.java
@@ -128,7 +128,7 @@
mainMethod.streamInstructions().noneMatch(
i -> i.isInvoke() && i.getMethod().name.toString().equals("m")));
- MethodSubject testInvokeInterface = main.uniqueMethodWithName("testInvokeInterface");
+ MethodSubject testInvokeInterface = main.uniqueMethodWithOriginalName("testInvokeInterface");
assertThat(testInvokeInterface, isPresent());
// With call site optimizations, the dynamic type of the argument is accurate (Impl1),
// hence the accurate resolution of the method call, resulting in rule application.
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
index 81d33fc..4509531 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/DeadFieldAfterAssumevaluesTest.java
@@ -78,7 +78,7 @@
assertTrue(mainMethod.streamInstructions()
.noneMatch(i -> i.isIf() || i.isIfEqz() || i.isIfNez()));
- FieldSubject hasR8 = main.uniqueFieldWithName("HAS_R8");
+ FieldSubject hasR8 = main.uniqueFieldWithOriginalName("HAS_R8");
assertThat(hasR8, not(isPresent()));
MethodSubject clinit = main.clinit();
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
index ce5e0fe..ee49eb3 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
@@ -230,13 +230,13 @@
private void compatCodePresent(CodeInspector inspector) {
ClassSubject compatLibrary = inspector.clazz(compatLibraryClassName);
assertThat(compatLibrary, isPresent());
- assertThat(compatLibrary.uniqueMethodWithName("compatMethod"), isPresent());
+ assertThat(compatLibrary.uniqueMethodWithOriginalName("compatMethod"), isPresent());
}
private void compatCodeNotPresent(CodeInspector inspector) {
ClassSubject compatLibrary = inspector.clazz(compatLibraryClassName);
assertThat(compatLibrary, isPresent());
- assertThat(compatLibrary.uniqueMethodWithName("compatMethod"), not(isPresent()));
+ assertThat(compatLibrary.uniqueMethodWithOriginalName("compatMethod"), not(isPresent()));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
index 5c7a755..f37d00a 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesDotsTest.java
@@ -69,9 +69,9 @@
private void inspect(CodeInspector inspector) {
ClassSubject clazz = inspector.clazz(Main.class);
assertTrue(clazz.getDexProgramClass().annotations().isEmpty());
- MethodSubject main = clazz.uniqueMethodWithName("main");
+ MethodSubject main = clazz.uniqueMethodWithOriginalName("main");
assertTrue(main.getMethod().annotations().isEmpty());
- FieldSubject field = clazz.uniqueFieldWithName("field");
+ FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
assertTrue(field.getField().annotations().isEmpty());
assertTrue(
clazz.getDexProgramClass().sourceFile == null
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
index 84b88e6..2d2160b 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepSignatureTest.java
@@ -96,17 +96,18 @@
assertThat(keptClass, isPresent());
assertEquals(
"<T:Ljava/lang/Object;>Ljava/lang/Object;", keptClass.getFinalSignatureAttribute());
- FieldSubject keptField = keptClass.uniqueFieldWithName("keptField");
+ FieldSubject keptField = keptClass.uniqueFieldWithOriginalName("keptField");
assertThat(keptField, isPresent());
assertEquals("TT;", keptField.getFinalSignatureAttribute());
- MethodSubject keptMethod = keptClass.uniqueMethodWithName("keptMethod");
+ MethodSubject keptMethod = keptClass.uniqueMethodWithOriginalName("keptMethod");
assertThat(keptMethod, isPresent());
assertEquals("<R:Ljava/lang/Object;>(TT;)TR;", keptMethod.getFinalSignatureAttribute());
// For all remaining classes and members, we should only keep signatures if in compat mode.
- checkMemberSignature(keptClass.uniqueFieldWithName("notKeptField"), keepForNotKept, "TT;");
checkMemberSignature(
- keptClass.uniqueMethodWithName("notKeptMethod"),
+ keptClass.uniqueFieldWithOriginalName("notKeptField"), keepForNotKept, "TT;");
+ checkMemberSignature(
+ keptClass.uniqueMethodWithOriginalName("notKeptMethod"),
keepForNotKept,
"<R:Ljava/lang/Object;>(TT;)TR;");
@@ -119,9 +120,11 @@
assertNull(notKeptClass.getFinalSignatureAttribute());
}
checkMemberSignature(
- notKeptClass.uniqueFieldWithName("notKeptField"), keepForNotKept, "Ljava/util/List<TP;>;");
+ notKeptClass.uniqueFieldWithOriginalName("notKeptField"),
+ keepForNotKept,
+ "Ljava/util/List<TP;>;");
checkMemberSignature(
- notKeptClass.uniqueMethodWithName("notKeptMethod"),
+ notKeptClass.uniqueMethodWithOriginalName("notKeptMethod"),
keepForNotKept,
"(TP;TP;)Ljava/util/List<TP;>;");
}
diff --git a/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java b/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
index 27f7735..5b2bd38 100644
--- a/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/convertchecknotnull/ConvertCheckNotNullTest.java
@@ -76,9 +76,11 @@
.count());
assertThat(
- mainClassSubject.uniqueMethodWithName("requireNonNullWithoutReturn"), isAbsent());
+ mainClassSubject.uniqueMethodWithOriginalName("requireNonNullWithoutReturn"),
+ isAbsent());
assertThat(
- mainClassSubject.uniqueMethodWithName("requireNonNullWithReturn"), isAbsent());
+ mainClassSubject.uniqueMethodWithOriginalName("requireNonNullWithReturn"),
+ isAbsent());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutput(getExpectedOutput());
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
index 14c99ba..620c73d 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
@@ -172,64 +172,72 @@
assertThat(superIfaceSubject, isPresent());
if (interfaceMethodsKept) {
assertEquals(
- expected.contains("m1"), superIfaceSubject.uniqueMethodWithName("m1").isPresent());
+ expected.contains("m1"),
+ superIfaceSubject.uniqueMethodWithOriginalName("m1").isPresent());
if (expected.contains("m1")) {
- assertThat(superIfaceSubject.uniqueMethodWithName("m1"), isAbstract());
+ assertThat(superIfaceSubject.uniqueMethodWithOriginalName("m1"), isAbstract());
}
}
ClassSubject subIfaceSubject = inspector.clazz(SubIface.class);
assertThat(subIfaceSubject, isPresent());
if (interfaceMethodsKept) {
- assertEquals(expected.contains("m2"), subIfaceSubject.uniqueMethodWithName("m2").isPresent());
+ assertEquals(
+ expected.contains("m2"), subIfaceSubject.uniqueMethodWithOriginalName("m2").isPresent());
if (expected.contains("m2")) {
- assertThat(subIfaceSubject.uniqueMethodWithName("m2"), isAbstract());
+ assertThat(subIfaceSubject.uniqueMethodWithOriginalName("m2"), isAbstract());
}
}
ClassSubject subSubIfaceSubject = inspector.clazz(SubSubIface.class);
assertThat(subSubIfaceSubject, isPresent());
if (interfaceMethodsKept) {
assertEquals(
- expected.contains("m3"), subSubIfaceSubject.uniqueMethodWithName("m3").isPresent());
+ expected.contains("m3"),
+ subSubIfaceSubject.uniqueMethodWithOriginalName("m3").isPresent());
if (expected.contains("m3")) {
- assertThat(subSubIfaceSubject.uniqueMethodWithName("m3"), isAbstract());
+ assertThat(subSubIfaceSubject.uniqueMethodWithOriginalName("m3"), isAbstract());
}
}
ClassSubject implSubject = inspector.clazz(Impl.class);
assertThat(implSubject, isPresent());
if (interfaceMethodsKept) {
- assertEquals(expected.contains("m1"), implSubject.uniqueMethodWithName("m1").isPresent());
- assertEquals(expected.contains("m2"), implSubject.uniqueMethodWithName("m2").isPresent());
- assertEquals(expected.contains("m3"), implSubject.uniqueMethodWithName("m3").isPresent());
+ assertEquals(
+ expected.contains("m1"), implSubject.uniqueMethodWithOriginalName("m1").isPresent());
+ assertEquals(
+ expected.contains("m2"), implSubject.uniqueMethodWithOriginalName("m2").isPresent());
+ assertEquals(
+ expected.contains("m3"), implSubject.uniqueMethodWithOriginalName("m3").isPresent());
}
- assertEquals(expected.contains("m4"), implSubject.uniqueMethodWithName("m4").isPresent());
+ assertEquals(
+ expected.contains("m4"), implSubject.uniqueMethodWithOriginalName("m4").isPresent());
ClassSubject subImplSubject = inspector.clazz(SubImpl.class);
assertThat(subImplSubject, isPresent());
- assertThat(subImplSubject.uniqueMethodWithName("m1"), not(isPresent()));
- assertThat(subImplSubject.uniqueMethodWithName("m2"), not(isPresent()));
- assertThat(subImplSubject.uniqueMethodWithName("m3"), not(isPresent()));
- assertThat(subImplSubject.uniqueMethodWithName("m4"), not(isPresent()));
- assertEquals(expected.contains("m5"), subImplSubject.uniqueMethodWithName("m5").isPresent());
+ assertThat(subImplSubject.uniqueMethodWithOriginalName("m1"), not(isPresent()));
+ assertThat(subImplSubject.uniqueMethodWithOriginalName("m2"), not(isPresent()));
+ assertThat(subImplSubject.uniqueMethodWithOriginalName("m3"), not(isPresent()));
+ assertThat(subImplSubject.uniqueMethodWithOriginalName("m4"), not(isPresent()));
+ assertEquals(
+ expected.contains("m5"), subImplSubject.uniqueMethodWithOriginalName("m5").isPresent());
ClassSubject subSubImplSubject = inspector.clazz(SubSubImpl.class);
assertThat(subSubImplSubject, isPresent());
// FOO
assertEquals(
subSubImplExpected.contains("m1"),
- subSubImplSubject.uniqueMethodWithName("m1").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m1").isPresent());
assertEquals(
subSubImplExpected.contains("m2"),
- subSubImplSubject.uniqueMethodWithName("m2").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m2").isPresent());
assertEquals(
subSubImplExpected.contains("m3"),
- subSubImplSubject.uniqueMethodWithName("m3").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m3").isPresent());
assertEquals(
subSubImplExpected.contains("m4"),
- subSubImplSubject.uniqueMethodWithName("m4").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m4").isPresent());
assertEquals(
subSubImplExpected.contains("m5"),
- subSubImplSubject.uniqueMethodWithName("m5").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m5").isPresent());
assertEquals(
subSubImplExpected.contains("m6"),
- subSubImplSubject.uniqueMethodWithName("m6").isPresent());
+ subSubImplSubject.uniqueMethodWithOriginalName("m6").isPresent());
}
private void checkAllMethodsInterfacesKept(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
index 265e46a..e1fab88 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
@@ -52,7 +52,7 @@
private void inspect(CodeInspector codeInspector) {
ClassSubject c = codeInspector.clazz(C.class);
assertThat(c, isPresent());
- MethodSubject m = c.uniqueMethodWithName("m");
+ MethodSubject m = c.uniqueMethodWithOriginalName("m");
assertThat(m, isPresent());
assertTrue(m.getMethod().hasCode());
// TODO(b/124017330): Verify that I$-CC.m() has been inlined into C.m().
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
index 42bda91..8e63f60 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumArrayInAnnotationTest.java
@@ -67,13 +67,13 @@
inspector -> {
assertThat(inspector.clazz(Enum.class), isPresentAndRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
isPresentAndNotRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
isPresentAndNotRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_THREE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_THREE"),
isPresentAndRenamed());
minifiedEnumName.set(inspector.clazz(Enum.class).getFinalName());
})
@@ -114,13 +114,13 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_THREE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_THREE"),
useGenericEnumsRule ? isPresentAndRenamed() : isPresentAndNotRenamed());
})
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -139,10 +139,10 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_ONE"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
assertThat(
- inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_TWO"),
+ inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_TWO"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
})
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
index 5de0ff2..92e2c31 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationTest.java
@@ -66,10 +66,10 @@
inspector -> {
assertThat(inspector.clazz(Enum.class), isPresentAndRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
isPresentAndNotRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
isPresentAndRenamed());
minifiedEnumName.set(inspector.clazz(Enum.class).getFinalName());
})
@@ -111,10 +111,10 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"),
useGenericEnumsRule ? isPresentAndRenamed() : isPresentAndNotRenamed());
})
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -133,7 +133,7 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(minifiedEnumName.get()).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(minifiedEnumName.get()).uniqueFieldWithOriginalName("TEST_ONE"),
parameters.isCfRuntime() ? isPresentAndNotRenamed() : isPresentAndRenamed());
})
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
index bc2e7ac..f769adb 100644
--- a/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/enums/EnumInAnnotationWhereAnnotationIsDeadTest.java
@@ -47,9 +47,10 @@
.inspect(
inspector -> {
assertThat(
- inspector.clazz(Enum.class).uniqueFieldWithName("TEST_ONE"),
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_ONE"),
isPresentAndRenamed());
- assertThat(inspector.clazz(Enum.class).uniqueFieldWithName("TEST_TWO"), isAbsent());
+ assertThat(
+ inspector.clazz(Enum.class).uniqueFieldWithOriginalName("TEST_TWO"), isAbsent());
})
.assertSuccessWithOutput(EXPECTED_RESULT);
}
diff --git a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
index eab4bff..7cf7921 100644
--- a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
+++ b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking13Test.java
@@ -52,7 +52,7 @@
private static void shaking13EnsureFieldWritesCorrect(CodeInspector inspector) {
ClassSubject mainClass = inspector.clazz("shaking13.Shaking");
- MethodSubject testMethod = mainClass.uniqueMethodWithName("fieldTest");
+ MethodSubject testMethod = mainClass.uniqueMethodWithOriginalName("fieldTest");
Assert.assertTrue(testMethod.isPresent());
Iterator<FieldAccessInstructionSubject> iterator =
testMethod.iterateInstructions(InstructionSubject::isFieldAccess);
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
index 2e726b0..1870c7e 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultctor/KeepClassMembersDefaultCtorTest.java
@@ -69,9 +69,9 @@
inspector -> {
assertThat(inspector.clazz(A.class), isPresent());
assertThat(inspector.clazz(A.class).init(), isAbsent());
- assertThat(inspector.clazz(A.class).uniqueFieldWithName("y"), isPresent());
+ assertThat(inspector.clazz(A.class).uniqueFieldWithOriginalName("y"), isPresent());
assertThat(
- inspector.clazz(A.class).uniqueFieldWithName("x"),
+ inspector.clazz(A.class).uniqueFieldWithOriginalName("x"),
fullMode ? isAbsent() : isPresent());
})
.assertFailureWithErrorThatThrows(NoSuchMethodException.class);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
index 7c3a2d9..5559309 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
@@ -88,9 +88,10 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(ClassForIf.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, not(isPresent()));
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, isPresent());
assertFalse(methodSubject.getMethod().accessFlags.isPublic());
classSubject = inspector.clazz(ClassForSubsequent.class);
@@ -122,17 +123,18 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(ClassForIf.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, not(isPresent()));
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.getMethod().accessFlags.isPublic());
classSubject = inspector.clazz(ClassForSubsequent.class);
assertThat(classSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, not(isPresent()));
});
}
@@ -161,17 +163,18 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(ClassForIf.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, not(isPresent()));
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, isPresent());
assertTrue(methodSubject.getMethod().accessFlags.isPublic());
classSubject = inspector.clazz(ClassForSubsequent.class);
assertThat(classSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, not(isPresent()));
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, isPresent());
assertEquals(shrinker.isR8(), methodSubject.getMethod().accessFlags.isPublic());
});
@@ -201,16 +204,17 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(ClassForIf.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, not(isPresent()));
classSubject = inspector.clazz(ClassForSubsequent.class);
assertThat(classSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, not(isPresent()));
});
}
@@ -239,16 +243,17 @@
inspector -> {
ClassSubject classSubject = inspector.clazz(ClassForIf.class);
assertThat(classSubject, isPresent());
- MethodSubject methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ MethodSubject methodSubject =
+ classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, not(isPresent()));
classSubject = inspector.clazz(ClassForSubsequent.class);
assertThat(classSubject, isPresent());
- methodSubject = classSubject.uniqueMethodWithName("publicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("publicMethod");
assertThat(methodSubject, not(isPresent()));
- methodSubject = classSubject.uniqueMethodWithName("nonPublicMethod");
+ methodSubject = classSubject.uniqueMethodWithOriginalName("nonPublicMethod");
assertThat(methodSubject, isPresent());
assertEquals(shrinker.isR8(), methodSubject.getMethod().accessFlags.isPublic());
});
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
index 70f8903..5f89295 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfSimilarClassSpecificationBundlingTest.java
@@ -148,13 +148,13 @@
codeInspector -> {
ClassSubject aSubject = codeInspector.clazz(A.class);
assertThat(aSubject, isPresent());
- assertThat(aSubject.uniqueMethodWithName("a"), isPresent());
+ assertThat(aSubject.uniqueMethodWithOriginalName("a"), isPresent());
ClassSubject bSubject = codeInspector.clazz(B.class);
assertThat(bSubject, isPresent());
- assertThat(bSubject.uniqueMethodWithName("b"), isPresent());
+ assertThat(bSubject.uniqueMethodWithOriginalName("b"), isPresent());
ClassSubject cSubject = codeInspector.clazz(C.class);
assertThat(cSubject, isPresent());
- assertThat(cSubject.uniqueMethodWithName("c"), isPresent());
+ assertThat(cSubject.uniqueMethodWithOriginalName("c"), isPresent());
});
assertEquals(expectedClassEvaluations, box.data.numberOfProguardIfRuleClassEvaluations);
assertEquals(expectedMemberEvaluations, box.data.numberOfProguardIfRuleMemberEvaluations);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
index fdef324..28b399c 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/NoLongerSatisfiedIfRuleTest.java
@@ -52,7 +52,7 @@
ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- assertThat(bClassSubject.uniqueMethodWithName("m"), isAbsent());
+ assertThat(bClassSubject.uniqueMethodWithOriginalName("m"), isAbsent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
index 7a0d692..8149782 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/StaticFinalFieldInliningTest.java
@@ -69,7 +69,9 @@
private static void assertHasStaticGet(
boolean expected, String methodName, CodeInspector inspector) {
MethodSubject method =
- inspector.clazz(StaticFinalFieldInliningSource.class).uniqueMethodWithName(methodName);
+ inspector
+ .clazz(StaticFinalFieldInliningSource.class)
+ .uniqueMethodWithOriginalName(methodName);
assertEquals(
method.getMethod().codeToString(),
expected,
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
index 5a27372..1defdee 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/accessrelaxation/IfRuleWithAccessRelaxationTest.java
@@ -62,11 +62,12 @@
.inspector();
assertTrue(inspector.clazz(TestClass.class).isPublic());
- assertThat(inspector.clazz(TestClass.class).uniqueFieldWithName("field"), isPublic());
+ assertThat(inspector.clazz(TestClass.class).uniqueFieldWithOriginalName("field"), isPublic());
assertThat(
- inspector.clazz(TestClass.class).uniqueMethodWithName("privateMethod"),
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("privateMethod"),
allOf(isPublic(), isFinal()));
- assertThat(inspector.clazz(TestClass.class).uniqueMethodWithName("virtualMethod"), isPublic());
+ assertThat(
+ inspector.clazz(TestClass.class).uniqueMethodWithOriginalName("virtualMethod"), isPublic());
assertThat(inspector.clazz(Unused1.class), isPresent());
assertThat(inspector.clazz(Unused2.class), isPresent());
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
index e841ffc..c74b2b1 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/applymapping/IfRuleWithApplyMappingTest.java
@@ -62,7 +62,9 @@
private void inspect(CodeInspector inspector) {
MethodSubject methodSubject =
- inspector.clazz(IfRuleWithApplyMappingTestClass.class).uniqueMethodWithName("method");
+ inspector
+ .clazz(IfRuleWithApplyMappingTestClass.class)
+ .uniqueMethodWithOriginalName("method");
assertThat(methodSubject, isPresent());
assertEquals(
A.class.getTypeName(),
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
index 01d977a..0b486ff 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
@@ -88,8 +88,8 @@
if (parameters.isCfRuntime()) {
ClassSubject itfClass = inspector.clazz(Interface.class.getTypeName());
assertThat(itfClass, isPresent());
- assertThat(itfClass.uniqueMethodWithName("staticMethod"), isPresent());
- assertThat(itfClass.uniqueMethodWithName("virtualMethod"), isPresent());
+ assertThat(itfClass.uniqueMethodWithOriginalName("staticMethod"), isPresent());
+ assertThat(itfClass.uniqueMethodWithOriginalName("virtualMethod"), isPresent());
assertThat(inspector.clazz(Unused1.class), isPresent());
assertThat(inspector.clazz(Unused2.class), isPresent());
return;
@@ -100,7 +100,7 @@
// NeverInline is only applicable to the static method at this point (could change).
assertEquals(1, classSubject.allMethods().size());
- MethodSubject staticMethodSubject = classSubject.uniqueMethodWithName("staticMethod");
+ MethodSubject staticMethodSubject = classSubject.uniqueMethodWithOriginalName("staticMethod");
assertThat(staticMethodSubject, allOf(isPresent(), isPublic(), isStatic()));
assertTrue(staticMethodSubject.streamInstructions().anyMatch(i -> i.isConstString(STATIC_STR)));
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
index 8fab4c1..45698a5 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/KeepIfPresentRuleWithVerticalClassMergingTest.java
@@ -51,7 +51,7 @@
ClassSubject classBSubject = inspector.clazz(B.class);
assertThat(classBSubject, isPresent());
assertThat(classBSubject.init(), isPresent());
- assertThat(classBSubject.uniqueMethodWithName("greet"), isPresent());
+ assertThat(classBSubject.uniqueMethodWithOriginalName("greet"), isPresent());
assertEquals(2, classBSubject.allMethods().size());
})
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
index 9dd4b60..6f80b77 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
@@ -57,7 +57,7 @@
ClassSubject classSubject = inspector.clazz(A.class);
assertThat(classSubject, isPresent());
- FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithOriginalName("greeting");
assertThat(fieldSubject, isPresentAndNotRenamed());
}
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
index e42dfe3..1a13a8d 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepInterfaceMethodTest.java
@@ -97,7 +97,7 @@
private void checkClassAndMethodIsPresent(CodeInspector inspector, Class<?> clazz) {
ClassSubject clazzSubject = inspector.clazz(clazz);
assertThat(clazzSubject, isPresent());
- MethodSubject foo = clazzSubject.uniqueMethodWithName("foo");
+ MethodSubject foo = clazzSubject.uniqueMethodWithOriginalName("foo");
assertThat(foo, isPresentAndNotRenamed());
}
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
index 4f8131d..41f3dcc 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
@@ -71,7 +71,7 @@
assertThat(classSubject, isPresent());
MethodSubject method;
- method = classSubject.uniqueMethodWithName("apiNoArgs");
+ method = classSubject.uniqueMethodWithOriginalName("apiNoArgs");
assertThat(method, isPresent());
assertEquals(keepParameterNames, method.hasLocalVariableTable());
if (keepParameterNames) {
@@ -83,12 +83,12 @@
assertTrue(method.getLocalVariableTable().isEmpty());
}
- method = classSubject.uniqueMethodWithName("apiNoArgsStatic");
+ method = classSubject.uniqueMethodWithOriginalName("apiNoArgsStatic");
assertThat(method, isPresent());
assertFalse(method.hasLocalVariableTable());
assertTrue(method.getLocalVariableTable().isEmpty());
- method = classSubject.uniqueMethodWithName("api1");
+ method = classSubject.uniqueMethodWithOriginalName("api1");
assertThat(method, isPresent());
assertEquals(keepParameterNames, method.hasLocalVariableTable());
if (keepParameterNames) {
@@ -112,7 +112,7 @@
assertTrue(method.getLocalVariableTable().isEmpty());
}
- method = classSubject.uniqueMethodWithName("api2");
+ method = classSubject.uniqueMethodWithOriginalName("api2");
assertThat(method, isPresent());
assertEquals(keepParameterNames, method.hasLocalVariableTable());
if (keepParameterNames) {
@@ -132,7 +132,7 @@
assertTrue(method.getLocalVariableTable().isEmpty());
}
- method = classSubject.uniqueMethodWithName("api3");
+ method = classSubject.uniqueMethodWithOriginalName("api3");
assertThat(method, isPresent());
assertEquals(keepParameterNames, method.hasLocalVariableTable());
if (keepParameterNames) {
@@ -193,7 +193,7 @@
MethodSubject method;
for (String name : new String[] {"apiNoArgs", "apiNoArgsStatic", "api1", "api2", "api3"}) {
- method = classSubject.uniqueMethodWithName(name);
+ method = classSubject.uniqueMethodWithOriginalName(name);
assertThat(method, isPresent());
assertEquals(enableMinification, method.isRenamed());
assertFalse(method.hasLocalVariableTable());
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
index abd2407..0b91059 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
@@ -62,7 +62,7 @@
ClassSubject classSubject = inspector.clazz("Api");
assertThat(classSubject, isPresent());
- MethodSubject method = classSubject.uniqueMethodWithName("api1");
+ MethodSubject method = classSubject.uniqueMethodWithOriginalName("api1");
assertThat(method, isPresent());
assertEquals(keepParameterNames, method.hasLocalVariableTable());
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
index 94bdbf1..915d92b 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
@@ -6,6 +6,7 @@
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
+import com.android.tools.r8.JdkClassFileProvider;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -45,6 +46,7 @@
public void test() throws Throwable {
testForR8(Backend.CF)
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addLibraryProvider(JdkClassFileProvider.fromSystemJdk())
.addKeepRuleFiles(MAIN_KEEP)
.addKeepRules(WHY_ARE_YOU_KEEPING_ALL)
.collectStdout()
diff --git a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
index 104f2cd..2699e27 100644
--- a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
@@ -68,7 +68,7 @@
for (Class<?> nonEscapingClass : nonEscapingClasses) {
ClassSubject classSubject = inspector.clazz(nonEscapingClass);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
+ assertThat(classSubject.uniqueMethodWithOriginalName("toString"), not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
index 9fe2a68..438355c 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
@@ -74,23 +74,26 @@
private void checkMethods(CodeInspector inspector, Set<String> expected, Shrinker shrinker) {
ClassSubject superSubject = inspector.clazz(Super.class);
assertThat(superSubject, isPresent());
- MethodSubject m1 = superSubject.uniqueMethodWithName("m1");
+ MethodSubject m1 = superSubject.uniqueMethodWithOriginalName("m1");
assertEquals(expected.contains("m1") && shrinker != Shrinker.R8Full, m1.isPresent());
if (m1.isPresent()) {
assertTrue(m1.isAbstract());
}
ClassSubject subSubject = inspector.clazz(Sub.class);
assertThat(subSubject, isPresent());
- MethodSubject m2 = subSubject.uniqueMethodWithName("m2");
+ MethodSubject m2 = subSubject.uniqueMethodWithOriginalName("m2");
assertEquals(expected.contains("m2") && shrinker != Shrinker.R8Full, m2.isPresent());
if (m2.isPresent()) {
assertTrue(m2.isAbstract());
}
ClassSubject subSubSubject = inspector.clazz(SubSub.class);
assertThat(subSubSubject, isPresent());
- assertEquals(expected.contains("m1"), subSubSubject.uniqueMethodWithName("m1").isPresent());
- assertEquals(expected.contains("m2"), subSubSubject.uniqueMethodWithName("m2").isPresent());
- assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+ assertEquals(
+ expected.contains("m1"), subSubSubject.uniqueMethodWithOriginalName("m1").isPresent());
+ assertEquals(
+ expected.contains("m2"), subSubSubject.uniqueMethodWithOriginalName("m2").isPresent());
+ assertEquals(
+ expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
}
private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
index 2961a50..2cd5ff7 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/AbstractInterfaceMethodsTest.java
@@ -54,7 +54,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(J.class);
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
assertThat(inspector.clazz(I.class), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
index aa1fe71..cbb3fc9 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/DefaultInterfaceMethodsTest.java
@@ -56,7 +56,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(J.class);
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName("foo"), not(isPresent()));
+ assertThat(clazz.uniqueMethodWithOriginalName("foo"), not(isPresent()));
assertThat(inspector.clazz(I.class), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
index 91f4153..4331c76 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/InterfaceDefaultMethodKeptTest.java
@@ -53,7 +53,8 @@
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(
- codeInspector.clazz(A.class).uniqueMethodWithName("foo"), not(isPresent()));
+ codeInspector.clazz(A.class).uniqueMethodWithOriginalName("foo"),
+ not(isPresent()));
});
testForRuntime(parameters)
.addProgramClasses(Main.class)
@@ -77,7 +78,8 @@
assertThat(codeInspector.clazz(A.class), not(isPresent()));
assertThat(codeInspector.clazz(B.class), isPresent());
assertThat(
- codeInspector.clazz(B.class).uniqueMethodWithName("foo"), not(isPresent()));
+ codeInspector.clazz(B.class).uniqueMethodWithOriginalName("foo"),
+ not(isPresent()));
});
testForRuntime(parameters)
.addProgramClasses(Main.class)
@@ -100,12 +102,14 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(A.class).uniqueMethodWithName("foo"), isPresent());
+ assertThat(
+ codeInspector.clazz(A.class).uniqueMethodWithOriginalName("foo"),
+ isPresent());
assertThat(codeInspector.clazz(B.class), isPresent());
// TODO(b/144409021): We should be able to remove this.
assertEquals(
parameters.isDexRuntime(),
- codeInspector.clazz(B.class).uniqueMethodWithName("foo").isPresent());
+ codeInspector.clazz(B.class).uniqueMethodWithOriginalName("foo").isPresent());
});
testForRuntime(parameters)
.addProgramClasses(Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
index c8b8be2..ae43926 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/interfaces/SubTypeOverridesInterfaceMethodTest.java
@@ -52,7 +52,7 @@
inspector -> {
ClassSubject clazz = inspector.clazz(A.class);
assertThat(clazz, isPresent());
- assertThat(clazz.uniqueMethodWithName("foo"), isPresent());
+ assertThat(clazz.uniqueMethodWithOriginalName("foo"), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
index 54e57dd..cc63bd8 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
@@ -105,13 +105,16 @@
private void checkMethods(CodeInspector inspector, Set<String> expected) {
ClassSubject superSubject = inspector.clazz(Super.class);
assertThat(superSubject, isPresent());
- assertEquals(expected.contains("m1"), superSubject.uniqueMethodWithName("m1").isPresent());
+ assertEquals(
+ expected.contains("m1"), superSubject.uniqueMethodWithOriginalName("m1").isPresent());
ClassSubject subSubject = inspector.clazz(Sub.class);
assertThat(subSubject, isPresent());
- assertEquals(expected.contains("m2"), subSubject.uniqueMethodWithName("m2").isPresent());
+ assertEquals(
+ expected.contains("m2"), subSubject.uniqueMethodWithOriginalName("m2").isPresent());
ClassSubject subSubSubject = inspector.clazz(SubSub.class);
assertThat(subSubSubject, isPresent());
- assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+ assertEquals(
+ expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
}
private void checkAllMethodsAndAllConstructors(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
index e2f3886..ee03c78 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
@@ -62,13 +62,16 @@
private void checkMethods(CodeInspector inspector, Set<String> expected) {
ClassSubject superSubject = inspector.clazz(Super.class);
assertThat(superSubject, isPresent());
- assertEquals(expected.contains("m1"), superSubject.uniqueMethodWithName("m1").isPresent());
+ assertEquals(
+ expected.contains("m1"), superSubject.uniqueMethodWithOriginalName("m1").isPresent());
ClassSubject subSubject = inspector.clazz(Sub.class);
assertThat(subSubject, isPresent());
- assertEquals(expected.contains("m2"), subSubject.uniqueMethodWithName("m2").isPresent());
+ assertEquals(
+ expected.contains("m2"), subSubject.uniqueMethodWithOriginalName("m2").isPresent());
ClassSubject subSubSubject = inspector.clazz(SubSub.class);
assertThat(subSubSubject, isPresent());
- assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+ assertEquals(
+ expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
}
private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
index bb5b668..9bd8465 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
@@ -66,15 +66,16 @@
assertThat(superSubject, isPresent());
assertEquals(
shrinker != Shrinker.R8Full && expected.contains("m1"),
- superSubject.uniqueMethodWithName("m1").isPresent());
+ superSubject.uniqueMethodWithOriginalName("m1").isPresent());
ClassSubject subSubject = inspector.clazz(Sub.class);
assertThat(subSubject, isPresent());
assertEquals(
shrinker != Shrinker.R8Full && expected.contains("m2"),
- subSubject.uniqueMethodWithName("m2").isPresent());
+ subSubject.uniqueMethodWithOriginalName("m2").isPresent());
ClassSubject subSubSubject = inspector.clazz(SubSub.class);
assertThat(subSubSubject, isPresent());
- assertEquals(expected.contains("m3"), subSubSubject.uniqueMethodWithName("m3").isPresent());
+ assertEquals(
+ expected.contains("m3"), subSubSubject.uniqueMethodWithOriginalName("m3").isPresent());
}
public String allMethodsOutput(Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
index 5f8bc2e..94f4646 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
@@ -71,13 +71,15 @@
private void checkAllMethods(CodeInspector inspector, Shrinker shrinker, String name) {
ClassSubject superSubject = inspector.clazz(Super.class);
assertThat(superSubject, isPresent());
- assertEquals(shrinker != Shrinker.R8Full, superSubject.uniqueMethodWithName(name).isPresent());
+ assertEquals(
+ shrinker != Shrinker.R8Full, superSubject.uniqueMethodWithOriginalName(name).isPresent());
ClassSubject subSubject = inspector.clazz(Sub.class);
assertThat(subSubject, isPresent());
- assertEquals(shrinker != Shrinker.R8Full, subSubject.uniqueMethodWithName(name).isPresent());
+ assertEquals(
+ shrinker != Shrinker.R8Full, subSubject.uniqueMethodWithOriginalName(name).isPresent());
ClassSubject subSubSubject = inspector.clazz(SubSub.class);
assertThat(subSubSubject, isPresent());
- assertThat(subSubSubject.uniqueMethodWithName(name), isPresent());
+ assertThat(subSubSubject.uniqueMethodWithOriginalName(name), isPresent());
}
private void checkAllMethods(CodeInspector inspector, Shrinker shrinker) {
diff --git a/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java b/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
index 82b7339..83fd6bb 100644
--- a/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/modifiers/AccessFlagsCombinationsTest.java
@@ -59,52 +59,52 @@
assertEquals(
includePublic && includeNonStatic,
- classSubject.uniqueMethodWithName("publicMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("publicMethod").isPresent());
assertEquals(
includeProtected && includeNonStatic,
- classSubject.uniqueMethodWithName("protectedMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("protectedMethod").isPresent());
assertEquals(
includePrivate && includeNonStatic,
- classSubject.uniqueMethodWithName("privateMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("privateMethod").isPresent());
assertEquals(
includePackagePrivate && includeNonStatic,
- classSubject.uniqueMethodWithName("packagePrivateMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("packagePrivateMethod").isPresent());
assertEquals(
includePublic && includeStatic,
- classSubject.uniqueMethodWithName("publicStaticMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("publicStaticMethod").isPresent());
assertEquals(
includeProtected && includeStatic,
- classSubject.uniqueMethodWithName("protectedStaticMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("protectedStaticMethod").isPresent());
assertEquals(
includePrivate && includeStatic,
- classSubject.uniqueMethodWithName("privateStaticMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("privateStaticMethod").isPresent());
assertEquals(
includePackagePrivate && includeStatic,
- classSubject.uniqueMethodWithName("packagePrivateStaticMethod").isPresent());
+ classSubject.uniqueMethodWithOriginalName("packagePrivateStaticMethod").isPresent());
assertEquals(
includePublic && includeNonStatic,
- classSubject.uniqueFieldWithName("publicField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("publicField").isPresent());
assertEquals(
includeProtected && includeNonStatic,
- classSubject.uniqueFieldWithName("protectedField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("protectedField").isPresent());
assertEquals(
includePrivate && includeNonStatic,
- classSubject.uniqueFieldWithName("privateField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("privateField").isPresent());
assertEquals(
includePackagePrivate && includeNonStatic,
- classSubject.uniqueFieldWithName("packagePrivateField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("packagePrivateField").isPresent());
assertEquals(
includePublic && includeStatic,
- classSubject.uniqueFieldWithName("publicStaticField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("publicStaticField").isPresent());
assertEquals(
includeProtected && includeStatic,
- classSubject.uniqueFieldWithName("protectedStaticField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("protectedStaticField").isPresent());
assertEquals(
includePrivate && includeStatic,
- classSubject.uniqueFieldWithName("privateStaticField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("privateStaticField").isPresent());
assertEquals(
includePackagePrivate && includeStatic,
- classSubject.uniqueFieldWithName("packagePrivateStaticField").isPresent());
+ classSubject.uniqueFieldWithOriginalName("packagePrivateStaticField").isPresent());
}
public void runTest(
diff --git a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
index 8a4113a..3743fb8 100644
--- a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
@@ -58,7 +58,7 @@
.inspector();
ClassSubject itf = inspector.clazz(M_I);
assertThat(itf, isPresent());
- MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
+ MethodSubject mtd = itf.uniqueMethodWithOriginalName("onEnterForeground");
assertThat(mtd, isAbsent());
}
@@ -77,7 +77,7 @@
.inspector();
ClassSubject itf = inspector.clazz(M_I);
assertThat(itf, isPresent());
- MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
+ MethodSubject mtd = itf.uniqueMethodWithOriginalName("onEnterForeground");
assertThat(mtd, isPresentAndNotRenamed());
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java b/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
index 9d2b858..3e3a646 100644
--- a/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/reflection/FieldAccessTest.java
@@ -64,7 +64,7 @@
Assert.assertTrue(
inspector
.clazz(testClass)
- .uniqueMethodWithName("main")
+ .uniqueMethodWithOriginalName("main")
.streamInstructions()
.anyMatch(this::isInvokeGetField));
})
diff --git a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
index ad6b6ea..58c7558 100644
--- a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
@@ -118,7 +118,7 @@
} else {
assertThat(method, not(isPresent()));
assertThat(companionClass, isPresent());
- assertThat(companionClass.uniqueMethodWithName("method"), isPresent());
+ assertThat(companionClass.uniqueMethodWithOriginalName("method"), isPresent());
}
}
diff --git a/src/test/java/com/android/tools/r8/smali/JumboStringTest.java b/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
index e7b5fe6..d3a9e4d 100644
--- a/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
+++ b/src/test/java/com/android/tools/r8/smali/JumboStringTest.java
@@ -92,7 +92,7 @@
inspector -> {
ClassSubject main = inspector.clazz(DEFAULT_CLASS_NAME);
assertThat(main, isPresent());
- MethodSubject method = main.uniqueMethodWithName(DEFAULT_METHOD_NAME);
+ MethodSubject method = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME);
assertThat(method, isPresent());
assertTrue(method.streamInstructions().anyMatch(InstructionSubject::isJumboString));
});
@@ -143,10 +143,10 @@
inspector -> {
ClassSubject main = inspector.clazz(DEFAULT_CLASS_NAME);
assertThat(main, isPresent());
- MethodSubject method = main.uniqueMethodWithName(DEFAULT_METHOD_NAME);
+ MethodSubject method = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME);
assertThat(method, isPresent());
assertTrue(method.streamInstructions().anyMatch(InstructionSubject::isJumboString));
- MethodSubject method2 = main.uniqueMethodWithName(DEFAULT_METHOD_NAME + "2");
+ MethodSubject method2 = main.uniqueMethodWithOriginalName(DEFAULT_METHOD_NAME + "2");
assertThat(method2, isPresent());
assertTrue(method2.streamInstructions().anyMatch(InstructionSubject::isJumboString));
});
diff --git a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
index 23e8577..77909c0 100644
--- a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
+++ b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
@@ -59,13 +59,15 @@
ClassSubject mainClassSubject = inspector.clazz(Main.class);
assertThat(mainClassSubject, isPresent());
// The postStartupMethod() should be inlined into PostStartupClass.runPostStartup().
- assertThat(mainClassSubject.uniqueMethodWithName("postStartupMethod"), isAbsent());
+ assertThat(
+ mainClassSubject.uniqueMethodWithOriginalName("postStartupMethod"), isAbsent());
ClassSubject postStartupClassSubject = inspector.clazz(PostStartupClass.class);
assertThat(postStartupClassSubject, isPresent());
// The runPostStartup() method must not be inlined into Main.main().
assertThat(
- postStartupClassSubject.uniqueMethodWithName("runPostStartup"), isPresent());
+ postStartupClassSubject.uniqueMethodWithOriginalName("runPostStartup"),
+ isPresent());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Hello, world!");
diff --git a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
index db55acb..f8a5438 100644
--- a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
+++ b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
@@ -84,7 +84,8 @@
assertTrue(
mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isThrow));
- MethodSubject onClickMethodSubject = mainClassSubject.uniqueMethodWithName("onClick");
+ MethodSubject onClickMethodSubject =
+ mainClassSubject.uniqueMethodWithOriginalName("onClick");
assertThat(onClickMethodSubject, isPresent());
assertTrue(
onClickMethodSubject.streamInstructions().anyMatch(InstructionSubject::isThrow));
@@ -93,7 +94,8 @@
ClassSubject startupClassSubject = primaryDexInspector.clazz(AStartupClass.class);
assertThat(startupClassSubject, isPresent());
- MethodSubject startupMethodSubject = startupClassSubject.uniqueMethodWithName("foo");
+ MethodSubject startupMethodSubject =
+ startupClassSubject.uniqueMethodWithOriginalName("foo");
assertThat(startupMethodSubject, isPresent());
assertTrue(
startupMethodSubject.streamInstructions().noneMatch(InstructionSubject::isThrow));
@@ -113,7 +115,7 @@
.anyMatch(InstructionSubject::isThrow));
MethodSubject nonStartupMethodSubject =
- nonStartupClassSubject.uniqueMethodWithName("bar");
+ nonStartupClassSubject.uniqueMethodWithOriginalName("bar");
assertThat(nonStartupMethodSubject, isPresent());
assertTrue(
nonStartupMethodSubject
diff --git a/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
index c5bfa0d..35d810b 100644
--- a/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/testingannotations/NeverInlineStaticInterfaceMethodTest.java
@@ -50,7 +50,7 @@
ClassSubject iClassSubject = inspector.clazz(I.class);
assertThat(iClassSubject, isPresent());
- MethodSubject iMethodSubject = iClassSubject.uniqueMethodWithName("m");
+ MethodSubject iMethodSubject = iClassSubject.uniqueMethodWithOriginalName("m");
assertThat(iClassSubject, isPresent());
MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/utils/Smali.java b/src/test/java/com/android/tools/r8/utils/Smali.java
index 30274f0..4321812 100644
--- a/src/test/java/com/android/tools/r8/utils/Smali.java
+++ b/src/test/java/com/android/tools/r8/utils/Smali.java
@@ -112,7 +112,7 @@
try {
DexApplication dexApp = new ApplicationReader(app, options, Timing.empty()).read(executor);
ApplicationWriter writer =
- new ApplicationWriter(
+ ApplicationWriter.create(
AppView.createForD8(
AppInfo.createInitialAppInfo(
dexApp, GlobalSyntheticsStrategy.forNonSynthesizing())),
diff --git a/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java b/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
index 8279af3..acadcc6 100644
--- a/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
+++ b/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
@@ -6,13 +6,29 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.StringUtils.BraceType;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
-public class StringUtilsTest {
+@RunWith(Parameterized.class)
+public class StringUtilsTest extends TestBase {
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ public StringUtilsTest(TestParameters parameters) {
+ parameters.assertNoneRuntime();
+ }
@Test
public void splitLines() {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
index a790753..e353ee6 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
@@ -46,7 +46,7 @@
}
@Override
- public MethodSubject uniqueMethodWithName(String name) {
+ public MethodSubject uniqueMethodWithOriginalName(String name) {
return new AbsentMethodSubject();
}
@@ -70,7 +70,7 @@
}
@Override
- public FieldSubject uniqueFieldWithName(String name) {
+ public FieldSubject uniqueFieldWithOriginalName(String name) {
return new AbsentFieldSubject();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index db4985c..0b2b52c 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -105,7 +105,7 @@
public abstract MethodSubject uniqueMethodThatMatches(Predicate<FoundMethodSubject> predicate);
- public abstract MethodSubject uniqueMethodWithName(String name);
+ public abstract MethodSubject uniqueMethodWithOriginalName(String name);
public abstract MethodSubject uniqueMethodWithFinalName(String name);
@@ -172,7 +172,7 @@
public abstract FieldSubject field(String type, String name);
- public abstract FieldSubject uniqueFieldWithName(String name);
+ public abstract FieldSubject uniqueFieldWithOriginalName(String name);
public abstract FieldSubject uniqueFieldWithFinalName(String name);
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 2c304ad..ff35c6e 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -148,7 +148,7 @@
}
@Override
- public MethodSubject uniqueMethodWithName(String name) {
+ public MethodSubject uniqueMethodWithOriginalName(String name) {
MethodSubject methodSubject = null;
for (FoundMethodSubject candidate : allMethods()) {
if (candidate.getOriginalName(false).equals(name)) {
@@ -219,13 +219,14 @@
}
@Override
- public FieldSubject uniqueFieldWithName(String name) {
- return uniqueFieldWithName(name, null);
+ public FieldSubject uniqueFieldWithOriginalName(String name) {
+ return uniqueFieldWithOriginalName(name, null);
}
// TODO(b/169882658): This should be removed when we have identity mappings for ambiguous cases.
- public FieldSubject uniqueFieldWithName(String name, TypeReference originalType) {
+ public FieldSubject uniqueFieldWithOriginalName(String name, TypeReference originalType) {
Retracer retracer = codeInspector.retrace();
+ ClassReference finalReference = getFinalReference();
Set<FoundFieldSubject> candidates = Sets.newIdentityHashSet();
Set<FoundFieldSubject> sameTypeCandidates = Sets.newIdentityHashSet();
for (FoundFieldSubject candidate : allFields()) {
@@ -238,7 +239,8 @@
}
}
retracer
- .retraceField(fieldReference)
+ .retraceClass(finalReference)
+ .lookupField(candidate.getFinalName())
.forEach(
element -> {
RetracedFieldReference field = element.getField();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java b/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
index 4d4c84b..c06e09d 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/analysis/ProtoApplicationStats.java
@@ -225,7 +225,7 @@
continue;
}
FieldSubject fieldSubject =
- classSubject.uniqueFieldWithName(extensionField.name.toSourceString());
+ classSubject.uniqueFieldWithOriginalName(extensionField.name.toSourceString());
if (fieldSubject.isPresent()) {
generatedExtensionRegistryStats.spuriouslyRetainedExtensionFields.add(extensionField);
}
diff --git a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
index f44fff9..00a3fba 100644
--- a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
+++ b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
@@ -72,7 +72,8 @@
}
private void inspect(CodeInspector inspector) {
- MethodSubject methodOfInterest = inspector.clazz(Greeter.class).uniqueMethodWithName("dead");
+ MethodSubject methodOfInterest =
+ inspector.clazz(Greeter.class).uniqueMethodWithOriginalName("dead");
assertThat(methodOfInterest, isPresent());
if (parameters.isCfRuntime() || parameters.getApiLevel().isLessThan(AndroidApiLevel.L)) {
assertThat(methodOfInterest, not(isAbstract()));
diff --git a/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java b/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
index 3cc8749..03d7c66 100644
--- a/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
+++ b/src/test/java/com/android/tools/r8/workaround/InvokeVirtualToInterfaceVerifyErrorWorkaroundTest.java
@@ -68,7 +68,7 @@
assertThat(cameraDeviceUserClassSubject, isPresent());
MethodSubject mMethodSubject =
- cameraDeviceUserClassSubject.uniqueMethodWithName("m");
+ cameraDeviceUserClassSubject.uniqueMethodWithOriginalName("m");
assertThat(mMethodSubject, isPresent());
assertThat(mMethodSubject, invokesMethodWithName("close"));
}
diff --git a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
index 524abea..6bb56ca 100644
--- a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
@@ -1 +1 @@
-ae103f657ce219b839706397baac799745d46049
\ No newline at end of file
+ed1a6a57d899d32cc749160872cad5c2130566b7
\ No newline at end of file
diff --git a/third_party/retrace/binary_compatibility.tar.gz.sha1 b/third_party/retrace/binary_compatibility.tar.gz.sha1
index 750079a..5d61558 100644
--- a/third_party/retrace/binary_compatibility.tar.gz.sha1
+++ b/third_party/retrace/binary_compatibility.tar.gz.sha1
@@ -1 +1 @@
-ed632240a9f5652ed988ccf84c5f592a487d24c3
\ No newline at end of file
+189692be996b34e4ba4a069c148b20d7ff99abe7
\ No newline at end of file
diff --git a/tools/create_r8lib.py b/tools/create_r8lib.py
index c48eaca..b6189e6 100755
--- a/tools/create_r8lib.py
+++ b/tools/create_r8lib.py
@@ -96,7 +96,7 @@
cmd.extend(['--source-file-template', source_file_template])
cmd.extend(['--output', args.output])
cmd.extend(['--pg-map-output', args.output + '.map'])
- cmd.extend(['--lib', 'third_party/openjdk/openjdk-rt-1.8/rt.jar'])
+ cmd.extend(['--lib', jdk.GetJdkHome()])
if args.pg_conf:
for pgconf in args.pg_conf:
cmd.extend(['--pg-conf', pgconf])
