Merge commit '62b3a4af8a0017ca8ebd236845894af2b462bdf0' into dev-release
diff --git a/.gitignore b/.gitignore
index a5b9426..147cf9a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -217,6 +217,7 @@
third_party/youtube-developer/20200415.tar.gz
tmp/
tools/*.pyc
+tools/__pycache__
tools/*/art
tools/*/art-5.1.1
tools/*/art-5.1.1.tar.gz
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 4def5d0..b762557 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -271,6 +271,9 @@
if (result != null) {
appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
appView.pruneItems(result.prunedItems);
+ if (result.lens != null) {
+ appView.setGraphLens(result.lens);
+ }
}
new CfApplicationWriter(
appView,
@@ -315,6 +318,9 @@
if (result != null) {
appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
appView.pruneItems(result.prunedItems);
+ if (result.lens != null) {
+ appView.setGraphLens(result.lens);
+ }
}
new ApplicationWriter(
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 047df78..b12a940 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -445,6 +445,11 @@
internal.programConsumer = getProgramConsumer();
if (internal.isGeneratingClassFiles()) {
internal.cfToCfDesugar = true;
+ // Turn off switch optimizations when desugaring to class file format.
+ assert internal.enableSwitchRewriting;
+ internal.enableSwitchRewriting = false;
+ assert internal.enableStringSwitchConversion;
+ internal.enableStringSwitchConversion = false;
}
internal.mainDexListConsumer = getMainDexListConsumer();
internal.minimalMainDex = internal.debug || minimalMainDex;
diff --git a/src/main/java/com/android/tools/r8/GenerateMainDexList.java b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
index d260bcb..bf85148 100644
--- a/src/main/java/com/android/tools/r8/GenerateMainDexList.java
+++ b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
@@ -96,7 +96,8 @@
}
Enqueuer enqueuer =
- EnqueuerFactory.createForMainDexTracing(appView, subtypingInfo, graphConsumer);
+ EnqueuerFactory.createForFinalMainDexTracing(
+ appView, executor, subtypingInfo, graphConsumer, MainDexTracingResult.NONE);
Set<DexProgramClass> liveTypes = enqueuer.traceMainDex(mainDexRootSet, executor, timing);
// LiveTypes is the result.
MainDexTracingResult mainDexTracingResult = new MainDexListBuilder(liveTypes, appView).run();
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index f610d83..64fc53e 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -94,9 +94,19 @@
ExceptionUtils.withD8CompilationHandler(
options.reporter,
() -> {
+ // Desugar to class file format and turn off switch optimizations, as the final
+ // compilation with D8 or R8 will do that.
options.cfToCfDesugar = true;
+ assert options.enableSwitchRewriting;
+ options.enableSwitchRewriting = false;
+ assert options.enableStringSwitchConversion;
+ options.enableStringSwitchConversion = false;
+
desugar(app, options, executorService);
+
options.cfToCfDesugar = false;
+ options.enableSwitchRewriting = true;
+ options.enableStringSwitchConversion = true;
});
assert !options.cfToCfDesugar;
if (shrink) {
@@ -133,6 +143,9 @@
if (result != null) {
appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
appView.pruneItems(result.prunedItems);
+ if (result.lens != null) {
+ appView.setGraphLens(result.lens);
+ }
}
NamingLens namingLens = PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
diff --git a/src/main/java/com/android/tools/r8/PrintSeeds.java b/src/main/java/com/android/tools/r8/PrintSeeds.java
index 212eb32..4be995a 100644
--- a/src/main/java/com/android/tools/r8/PrintSeeds.java
+++ b/src/main/java/com/android/tools/r8/PrintSeeds.java
@@ -92,10 +92,9 @@
RootSet rootSet =
new RootSetBuilder(appView, subtypingInfo, options.getProguardConfiguration().getRules())
.run(executor);
- Enqueuer enqueuer = EnqueuerFactory.createForInitialTreeShaking(appView, subtypingInfo);
- AppInfoWithLiveness appInfo =
- enqueuer.traceApplication(
- rootSet, options.getProguardConfiguration().getDontWarnPatterns(), executor, timing);
+ Enqueuer enqueuer =
+ EnqueuerFactory.createForInitialTreeShaking(appView, executor, subtypingInfo);
+ AppInfoWithLiveness appInfo = enqueuer.traceApplication(rootSet, executor, timing);
RootSetBuilder.writeSeeds(
appInfo, System.out, type -> descriptors.contains(type.toDescriptorString()));
} catch (ExecutionException e) {
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 9e7a967..5e31835 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -31,7 +31,6 @@
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.DirectMappedDexApplication;
-import com.android.tools.r8.graph.DirectMappedDexApplication.Builder;
import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
import com.android.tools.r8.graph.InitClassLens;
@@ -49,8 +48,6 @@
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
-import com.android.tools.r8.ir.desugar.NestedPrivateMethodLens;
-import com.android.tools.r8.ir.desugar.R8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
import com.android.tools.r8.ir.optimize.MethodPoolCollection;
import com.android.tools.r8.ir.optimize.NestReducer;
@@ -332,7 +329,7 @@
.rebuildWithClassHierarchy(
MissingClasses.builderForInitialMissingClasses()
.addNewMissingClasses(new SubtypingInfo(appView).getMissingClasses())
- .reportMissingClasses(options)));
+ .reportMissingClasses(appView)));
}
// Add synthesized -assumenosideeffects from min api if relevant.
@@ -420,6 +417,8 @@
}
assert appView.appInfo().hasLiveness();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
assert verifyNoJarApplicationReaders(appView.appInfo().classes());
// Build conservative main dex content after first round of tree shaking. This is used
// by certain optimizations to avoid introducing additional class references into main dex
@@ -435,7 +434,7 @@
.run(executorService);
// Live types is the tracing result.
Set<DexProgramClass> mainDexBaseClasses =
- EnqueuerFactory.createForMainDexTracing(appView, subtypingInfo)
+ EnqueuerFactory.createForInitialMainDexTracing(appView, executorService, subtypingInfo)
.traceMainDex(mainDexRootSet, executorService, timing);
// Calculate the automatic main dex list according to legacy multidex constraints.
mainDexTracingResult = new MainDexListBuilder(mainDexBaseClasses, appView).run();
@@ -448,7 +447,6 @@
appView.dexItemFactory().clearTypeElementsCache();
if (options.getProguardConfiguration().isAccessModificationAllowed()) {
- AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
SubtypingInfo subtypingInfo = appViewWithLiveness.appInfo().computeSubtypingInfo();
GraphLens publicizedLens =
ClassAndMemberPublicizer.run(
@@ -466,29 +464,13 @@
}
}
- AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+ // This pass attempts to reduce the number of nests and nest size to allow further passes, and
+ // should therefore be run after the publicizer.
+ new NestReducer(appViewWithLiveness).run(executorService, timing);
+
appView.setGraphLens(new MemberRebindingAnalysis(appViewWithLiveness).run(executorService));
appView.appInfo().withLiveness().getFieldAccessInfoCollection().restrictToProgram(appView);
- if (options.shouldDesugarNests()) {
- timing.begin("NestBasedAccessDesugaring");
- R8NestBasedAccessDesugaring analyzer = new R8NestBasedAccessDesugaring(appViewWithLiveness);
- Builder appBuilder = getDirectApp(appView).builder();
- NestedPrivateMethodLens lens = analyzer.run(executorService, appBuilder);
- if (lens != null) {
- appView.rewriteWithLensAndApplication(lens, appBuilder.build());
- }
- timing.end();
- } else {
- timing.begin("NestReduction");
- // This pass attempts to reduce the number of nests and nest size
- // to allow further passes, specifically the class mergers, to do
- // a better job. This pass is better run before the class merger
- // but after the publicizer (cannot be run as part of the Enqueuer).
- new NestReducer(appViewWithLiveness).run(executorService);
- timing.end();
- }
-
boolean isKotlinLibraryCompilationWithInlinePassThrough =
options.enableCfByteCodePassThrough && appView.hasCfByteCodePassThroughMethods();
@@ -644,8 +626,12 @@
}
Enqueuer enqueuer =
- EnqueuerFactory.createForMainDexTracing(
- appView, new SubtypingInfo(appView), mainDexKeptGraphConsumer);
+ EnqueuerFactory.createForFinalMainDexTracing(
+ appView,
+ executorService,
+ new SubtypingInfo(appView),
+ mainDexKeptGraphConsumer,
+ mainDexTracingResult);
// Find classes which may have code executed before secondary dex files installation.
// Live types is the tracing result.
Set<DexProgramClass> mainDexBaseClasses =
@@ -694,13 +680,13 @@
Enqueuer enqueuer =
EnqueuerFactory.createForFinalTreeShaking(
appView,
+ executorService,
new SubtypingInfo(appView),
keptGraphConsumer,
prunedTypes);
appView.setAppInfo(
enqueuer.traceApplication(
appView.rootSet(),
- options.getProguardConfiguration().getDontWarnPatterns(),
executorService,
timing));
// Rerunning the enqueuer should not give rise to any method rewritings.
@@ -827,7 +813,9 @@
lens, appBuilder.build(), memberRebindingLens.getPrevious());
}
}
- assert Repackaging.verifyIdentityRepackaging(appView);
+ if (appView.appInfo().hasLiveness()) {
+ assert Repackaging.verifyIdentityRepackaging(appView.withLiveness());
+ }
// Add automatic main dex classes to an eventual manual list of classes.
if (!options.mainDexKeepRules.isEmpty()) {
@@ -838,12 +826,21 @@
appView.getSyntheticItems().computeFinalSynthetics(appView);
if (result != null) {
if (appView.appInfo().hasLiveness()) {
- appViewWithLiveness.setAppInfo(
- appViewWithLiveness.appInfo().rebuildWithLiveness(result.commit));
+ if (result.lens == null) {
+ appViewWithLiveness.setAppInfo(
+ appViewWithLiveness.appInfo().rebuildWithLiveness(result.commit));
+ } else {
+ appViewWithLiveness.rewriteWithLensAndApplication(
+ result.lens, result.commit.getApplication().asDirect());
+ }
+ appViewWithLiveness.pruneItems(result.prunedItems);
} else {
appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(result.commit));
+ appView.pruneItems(result.prunedItems);
+ if (result.lens != null) {
+ appView.setGraphLens(result.lens);
+ }
}
- appViewWithLiveness.pruneItems(result.prunedItems);
}
// Perform minification.
@@ -931,6 +928,8 @@
options,
ProguardMapSupplier.create(classNameMapper, options));
+ assert appView.getDontWarnConfiguration().validate(options);
+
options.printWarnings();
} catch (ExecutionException e) {
throw unwrapExecutionException(e);
@@ -1002,7 +1001,8 @@
SubtypingInfo subtypingInfo,
RuntimeTypeCheckInfo.Builder classMergingEnqueuerExtensionBuilder)
throws ExecutionException {
- Enqueuer enqueuer = EnqueuerFactory.createForInitialTreeShaking(appView, subtypingInfo);
+ Enqueuer enqueuer =
+ EnqueuerFactory.createForInitialTreeShaking(appView, executorService, subtypingInfo);
enqueuer.setAnnotationRemoverBuilder(annotationRemoverBuilder);
if (appView.options().enableInitializedClassesInInstanceMethodsAnalysis) {
enqueuer.registerAnalysis(new InitializedClassesInInstanceMethodsAnalysis(appView));
@@ -1021,7 +1021,6 @@
appView.setAppInfo(
enqueuer.traceApplication(
appView.rootSet(),
- options.getProguardConfiguration().getDontWarnPatterns(),
executorService,
timing));
NestedGraphLens lens = enqueuer.buildGraphLens();
@@ -1071,16 +1070,19 @@
SubtypingInfo subtypingInfo = new SubtypingInfo(appView);
if (forMainDex) {
enqueuer =
- EnqueuerFactory.createForMainDexTracing(
- appView, subtypingInfo, whyAreYouKeepingConsumer);
+ EnqueuerFactory.createForFinalMainDexTracing(
+ appView,
+ executorService,
+ subtypingInfo,
+ whyAreYouKeepingConsumer,
+ MainDexTracingResult.NONE);
enqueuer.traceMainDex(rootSet, executorService, timing);
} else {
enqueuer =
EnqueuerFactory.createForWhyAreYouKeeping(
- appView, subtypingInfo, whyAreYouKeepingConsumer);
+ appView, executorService, subtypingInfo, whyAreYouKeepingConsumer);
enqueuer.traceApplication(
rootSet,
- options.getProguardConfiguration().getDontWarnPatterns(),
executorService,
timing);
}
diff --git a/src/main/java/com/android/tools/r8/ReadProguardMap.java b/src/main/java/com/android/tools/r8/ReadProguardMap.java
index 31bc2d8..0e02ce0 100644
--- a/src/main/java/com/android/tools/r8/ReadProguardMap.java
+++ b/src/main/java/com/android/tools/r8/ReadProguardMap.java
@@ -38,7 +38,7 @@
if (args.length == 0) {
readProguardMapFile(DEFAULT_MAP_FILE_NAME);
} else {
- Arrays.asList(args).forEach((String name) -> readProguardMapFile(name));
+ Arrays.asList(args).forEach(this::readProguardMapFile);
}
timing.report();
}
diff --git a/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java b/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
index b4b0d5a..d56b873 100644
--- a/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
@@ -452,9 +452,9 @@
@Override
public void print(CfFrame frame) {
- String keys = join(frame.getLocals().keySet(), ",", BraceType.NONE);
- String values = join(frame.getLocals().values(), ",", BraceType.NONE, this::frameTypeType);
- String stack = join(frame.getStack(), ",", BraceType.NONE, this::frameTypeType);
+ String keys = join(frame.getLocals().keySet(), ",");
+ String values = join(",", frame.getLocals().values(), this::frameTypeType);
+ String stack = join(",", frame.getStack(), this::frameTypeType);
printNewInstruction(
"CfFrame",
"new "
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java b/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
index 6176b49..be6176b 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
@@ -65,6 +65,10 @@
return visitor.visit(this, other.asFieldInstruction(), CfFieldInstruction::specify);
}
+ public boolean isFieldGet() {
+ return opcode == Opcodes.GETFIELD || opcode == Opcodes.GETSTATIC;
+ }
+
@Override
public CfFieldInstruction asFieldInstruction() {
return this;
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
index 6c7f76f..00d4c93 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
@@ -170,6 +170,10 @@
!method.name.toString().equals(Constants.INSTANCE_INITIALIZER_NAME);
}
+ public boolean isInvokeStatic() {
+ return opcode == Opcodes.INVOKESTATIC;
+ }
+
public boolean isInvokeVirtual() {
return opcode == Opcodes.INVOKEVIRTUAL;
}
diff --git a/src/main/java/com/android/tools/r8/code/Instruction.java b/src/main/java/com/android/tools/r8/code/Instruction.java
index 977dafd..ccfd713 100644
--- a/src/main/java/com/android/tools/r8/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/code/Instruction.java
@@ -332,6 +332,9 @@
@Override
public final void acceptHashing(HashingVisitor visitor) {
// Rather than traverse the full instruction, the compare ID will likely give a reasonable hash.
+ // TODO(b/158159959): This will likely lead to a lot of distinct synthetics hashing to the same
+ // hash as many have the same instruction pattern such as an invoke of the impl method or a
+ // field access.
visitor.visitInt(getCompareToId());
}
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 ef6b7cd..bbe4a90 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -55,7 +55,7 @@
import com.android.tools.r8.naming.MemberNaming.Signature;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.position.MethodPosition;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.DexVersion;
import com.android.tools.r8.utils.InternalOptions;
@@ -323,7 +323,7 @@
for (DexType type : mapping.getTypes()) {
if (type.isClassType()) {
assert DexString.isValidSimpleName(apiLevel, type.getName());
- assert SyntheticItems.verifyNotInternalSynthetic(type);
+ assert SyntheticNaming.verifyNotInternalSynthetic(type);
}
}
diff --git a/src/main/java/com/android/tools/r8/dex/InheritanceClassInDexDistributor.java b/src/main/java/com/android/tools/r8/dex/InheritanceClassInDexDistributor.java
index 8e8750a..1183590 100644
--- a/src/main/java/com/android/tools/r8/dex/InheritanceClassInDexDistributor.java
+++ b/src/main/java/com/android/tools/r8/dex/InheritanceClassInDexDistributor.java
@@ -548,7 +548,7 @@
private void updateGroupsNumberOfIds(List<ClassGroup> groups) {
Collection<Future<?>> updateIdsTasks = new ArrayList<>(groups.size());
for (ClassGroup group : groups) {
- updateIdsTasks.add(executorService.submit(() -> group.updateNumbersOfIds()));
+ updateIdsTasks.add(executorService.submit(group::updateNumbersOfIds));
}
try {
ThreadUtils.awaitFutures(updateIdsTasks);
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 917f0de..7da0bc5 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -28,7 +28,7 @@
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -667,7 +667,7 @@
@Override
public boolean addType(DexType type) {
- assert SyntheticItems.verifyNotInternalSynthetic(type);
+ assert SyntheticNaming.verifyNotInternalSynthetic(type);
return types.add(type);
}
@@ -790,7 +790,7 @@
@Override
public boolean addType(DexType type) {
- assert SyntheticItems.verifyNotInternalSynthetic(type);
+ assert SyntheticNaming.verifyNotInternalSynthetic(type);
return maybeInsert(type, types, base.types);
}
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java
new file mode 100644
index 0000000..ff4a73d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java
@@ -0,0 +1,43 @@
+// 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.errors.dontwarn;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.shaking.ProguardConfiguration;
+import com.android.tools.r8.utils.InternalOptions;
+import java.util.Set;
+
+public abstract class DontWarnConfiguration {
+
+ public static DontWarnConfiguration create(ProguardConfiguration proguardConfiguration) {
+ if (proguardConfiguration != null && proguardConfiguration.hasDontWarnPatterns()) {
+ return new NonEmptyDontWarnConfiguration(
+ proguardConfiguration.getDontWarnPatterns(new Witness()));
+ }
+ return empty();
+ }
+
+ public static EmptyDontWarnConfiguration empty() {
+ return new EmptyDontWarnConfiguration();
+ }
+
+ public abstract Set<DexType> getNonMatches(Set<DexType> types);
+
+ public final boolean matches(DexClass clazz) {
+ return matches(clazz.getType());
+ }
+
+ public abstract boolean matches(DexType type);
+
+ public abstract boolean validate(InternalOptions options);
+
+ // Witness that can only be instantiated by the DontWarnConfiguration, to ensure that the dont
+ // warn patterns are only accessed via the DontWarnConfiguration.
+ public static class Witness {
+
+ private Witness() {}
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java
new file mode 100644
index 0000000..e115168
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java
@@ -0,0 +1,27 @@
+// 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.errors.dontwarn;
+
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.InternalOptions;
+import java.util.Set;
+
+public class EmptyDontWarnConfiguration extends DontWarnConfiguration {
+
+ @Override
+ public Set<DexType> getNonMatches(Set<DexType> types) {
+ return types;
+ }
+
+ @Override
+ public boolean matches(DexType type) {
+ return false;
+ }
+
+ @Override
+ public boolean validate(InternalOptions options) {
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java
new file mode 100644
index 0000000..e96cb83
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java
@@ -0,0 +1,89 @@
+// 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.errors.dontwarn;
+
+import static java.util.Collections.emptySet;
+
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.shaking.ProguardClassFilter;
+import com.android.tools.r8.shaking.ProguardClassNameList;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.Sets;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class NonEmptyDontWarnConfiguration extends DontWarnConfiguration {
+
+ private final List<ProguardClassNameList> dontWarnPatterns;
+ private final Map<ProguardClassNameList, Set<DexType>> matchedDontWarnPatterns =
+ new IdentityHashMap<>();
+
+ NonEmptyDontWarnConfiguration(ProguardClassFilter dontWarnPatterns) {
+ assert dontWarnPatterns != null;
+ assert !dontWarnPatterns.isEmpty();
+ this.dontWarnPatterns = dontWarnPatterns.getPatterns();
+ }
+
+ @Override
+ public Set<DexType> getNonMatches(Set<DexType> types) {
+ Set<DexType> nonMatches = Sets.newIdentityHashSet();
+ for (DexType type : types) {
+ if (!matches(type)) {
+ nonMatches.add(type);
+ }
+ }
+ return nonMatches;
+ }
+
+ @Override
+ public boolean matches(DexType type) {
+ for (ProguardClassNameList dontWarnPattern : dontWarnPatterns) {
+ if (dontWarnPattern.matches(type)) {
+ recordMatch(dontWarnPattern, type);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void recordMatch(ProguardClassNameList dontWarnPattern, DexType type) {
+ if (InternalOptions.assertionsEnabled()) {
+ matchedDontWarnPatterns
+ .computeIfAbsent(dontWarnPattern, ignore -> Sets.newIdentityHashSet())
+ .add(type);
+ }
+ }
+
+ @Override
+ public boolean validate(InternalOptions options) {
+ assert options.testing.allowUnnecessaryDontWarnWildcards
+ || validateNoUnnecessaryDontWarnWildcards();
+ assert options.testing.allowUnusedDontWarnRules || validateNoUnusedDontWarnPatterns();
+ return true;
+ }
+
+ public boolean validateNoUnnecessaryDontWarnWildcards() {
+ for (ProguardClassNameList dontWarnPattern : dontWarnPatterns) {
+ assert !dontWarnPattern.hasWildcards()
+ || matchedDontWarnPatterns.getOrDefault(dontWarnPattern, emptySet()).size() != 1
+ : "Unexpected unnecessary wildcard in -dontwarn "
+ + dontWarnPattern.toString()
+ + " (only matches "
+ + matchedDontWarnPatterns.get(dontWarnPattern).iterator().next().getTypeName()
+ + ")";
+ }
+ return true;
+ }
+
+ public boolean validateNoUnusedDontWarnPatterns() {
+ for (ProguardClassNameList dontWarnPattern : dontWarnPatterns) {
+ assert matchedDontWarnPatterns.containsKey(dontWarnPattern)
+ : "Unexpected unused rule -dontwarn " + dontWarnPattern.toString();
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index cfacdbb..302dff4 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -123,11 +123,6 @@
}
}
- public Collection<DexProgramClass> synthesizedClasses() {
- assert checkIfObsolete();
- return syntheticItems.getPendingSyntheticClasses();
- }
-
public Collection<DexProgramClass> classes() {
assert checkIfObsolete();
return app.classes();
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
index 56b1a53..8ff4d1e 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
@@ -15,12 +15,15 @@
import com.android.tools.r8.graph.ResolutionResult.IncompatibleClassResult;
import com.android.tools.r8.graph.ResolutionResult.NoSuchMethodResult;
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection.Builder;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.shaking.MainDexClasses;
import com.android.tools.r8.shaking.MissingClasses;
import com.android.tools.r8.synthesis.CommittedItems;
import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.TraversalContinuation;
import com.android.tools.r8.utils.TriConsumer;
@@ -287,31 +290,78 @@
}
/** Collect all interfaces that this type directly or indirectly implements. */
- public Set<DexType> implementedInterfaces(DexType type) {
+ public InterfaceCollection implementedInterfaces(DexType type) {
assert type.isClassType();
DexClass clazz = definitionFor(type);
if (clazz == null) {
- return Collections.emptySet();
+ return InterfaceCollection.empty();
}
// Fast path for a type below object with no interfaces.
if (clazz.superType == dexItemFactory().objectType && clazz.interfaces.isEmpty()) {
- return clazz.isInterface() ? Collections.singleton(type) : Collections.emptySet();
+ return clazz.isInterface()
+ ? InterfaceCollection.singleton(type)
+ : InterfaceCollection.empty();
}
// Slow path traverses the full super type hierarchy.
- Set<DexType> interfaces = Sets.newIdentityHashSet();
+ Builder builder = InterfaceCollection.builder();
if (clazz.isInterface()) {
- interfaces.add(type);
+ builder.addInterface(type, true);
}
- forEachSuperType(
- clazz,
- (superType, subclass, isInterface) -> {
- if (isInterface) {
- interfaces.add(superType);
+ // First find all interface leafs from the class super-type chain.
+ Set<DexType> seenAndKnown = Sets.newIdentityHashSet();
+ Deque<Pair<DexClass, Boolean>> worklist = new ArrayDeque<>();
+ {
+ DexClass implementor = clazz;
+ while (implementor != null) {
+ for (DexType iface : implementor.interfaces) {
+ if (seenAndKnown.contains(iface)) {
+ continue;
}
- });
- return interfaces;
+ boolean isKnown =
+ InterfaceCollection.isKnownToImplement(iface, implementor.getType(), options());
+ builder.addInterface(iface, isKnown);
+ if (isKnown) {
+ seenAndKnown.add(iface);
+ }
+ DexClass definition = definitionFor(iface);
+ if (definition != null && !definition.interfaces.isEmpty()) {
+ worklist.add(new Pair<>(definition, isKnown));
+ }
+ }
+ if (implementor.superType == null
+ || implementor.superType == options().dexItemFactory().objectType) {
+ break;
+ }
+ implementor = definitionFor(implementor.superType);
+ }
+ }
+ // Second complete the worklist of interfaces. All paths must be visited as an interface may
+ // be unknown on one but not on another.
+ while (!worklist.isEmpty()) {
+ Pair<DexClass, Boolean> item = worklist.poll();
+ DexClass implementor = item.getFirst();
+ assert !implementor.interfaces.isEmpty();
+ for (DexType itf : implementor.interfaces) {
+ if (seenAndKnown.contains(itf)) {
+ continue;
+ }
+ // A derived interface is known only if the full chain leading to it is known.
+ boolean isKnown =
+ item.getSecond()
+ && InterfaceCollection.isKnownToImplement(itf, implementor.getType(), options());
+ builder.addInterface(itf, isKnown);
+ if (isKnown) {
+ seenAndKnown.add(itf);
+ }
+ DexClass definition = definitionFor(itf);
+ if (definition != null && !definition.interfaces.isEmpty()) {
+ worklist.add(new Pair<>(definition, isKnown));
+ }
+ }
+ }
+ return builder.build();
}
public boolean isExternalizable(DexType type) {
diff --git a/src/main/java/com/android/tools/r8/graph/AppServices.java b/src/main/java/com/android/tools/r8/graph/AppServices.java
index c0c3976..bb61928 100644
--- a/src/main/java/com/android/tools/r8/graph/AppServices.java
+++ b/src/main/java/com/android/tools/r8/graph/AppServices.java
@@ -342,8 +342,7 @@
}
private void warn(String message, DexType type, Origin origin) {
- if (options.getProguardConfiguration() == null
- || !options.getProguardConfiguration().getDontWarnPatterns().matches(type)) {
+ if (!appView.getDontWarnConfiguration().matches(type)) {
options.reporter.warning(new StringDiagnostic(message, origin));
}
}
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 531c78a..489d0b6 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
+import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.DexValue.DexValueString;
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
@@ -57,6 +58,7 @@
private T appInfo;
private AppInfoWithClassHierarchy appInfoForDesugaring;
private AppServices appServices;
+ private final DontWarnConfiguration dontWarnConfiguration;
private final WholeProgramOptimizations wholeProgramOptimizations;
private GraphLens graphLens;
private InitClassLens initClassLens;
@@ -107,6 +109,7 @@
PrefixRewritingMapper mapper) {
assert appInfo != null;
this.appInfo = appInfo;
+ this.dontWarnConfiguration = DontWarnConfiguration.create(options().getProguardConfiguration());
this.wholeProgramOptimizations = wholeProgramOptimizations;
this.graphLens = GraphLens.getIdentityLens();
this.initClassLens = InitClassLens.getDefault();
@@ -251,6 +254,10 @@
this.appServices = appServices;
}
+ public DontWarnConfiguration getDontWarnConfiguration() {
+ return dontWarnConfiguration;
+ }
+
public boolean isClassEscapingIntoLibrary(DexType type) {
assert type.isClassType();
return classesEscapingIntoLibrary.test(type);
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index eb83898..4d45d55 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -247,6 +247,9 @@
public void acceptHashing(HashingVisitor visitor) {
// Rather than hash the entire content, hash the sizes and each instruction "type" which
// should provide a fast yet reasonably distinct key.
+ // TODO(b/158159959): This will likely lead to a lot of distinct synthetics hashing to the same
+ // hash as many have the same instruction pattern such as an invoke of the impl method or a
+ // field access.
visitor.visitInt(instructions.size());
visitor.visitInt(tryCatchRanges.size());
visitor.visitInt(localVariables.size());
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathField.java b/src/main/java/com/android/tools/r8/graph/ClasspathField.java
new file mode 100644
index 0000000..b40e51c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathField.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+public class ClasspathField extends DexClassAndField {
+
+ public ClasspathField(DexClasspathClass holder, DexEncodedField field) {
+ super(holder, field);
+ }
+
+ @Override
+ public boolean isClasspathField() {
+ return true;
+ }
+
+ @Override
+ public ClasspathField asClasspathField() {
+ return this;
+ }
+
+ @Override
+ public boolean isClasspathMember() {
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java b/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
index 9d2a941..0c58053 100644
--- a/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
@@ -23,6 +23,11 @@
}
@Override
+ public boolean isClasspathMember() {
+ return true;
+ }
+
+ @Override
public boolean isClasspathMethod() {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
index bcb7974..3483fbb 100644
--- a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
+++ b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
@@ -14,6 +14,8 @@
import com.android.tools.r8.graph.DexValue.DexValueString;
import com.android.tools.r8.graph.DexValue.DexValueType;
import com.android.tools.r8.ir.desugar.CovariantReturnTypeAnnotationTransformer;
+import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.structural.StructuralItem;
@@ -399,13 +401,18 @@
}
public static DexAnnotation createAnnotationSynthesizedClass(
- DexType synthesizingContext, DexItemFactory dexItemFactory) {
- DexValueType value = new DexValueType(synthesizingContext);
- DexAnnotationElement element = new DexAnnotationElement(dexItemFactory.valueString, value);
+ SyntheticKind kind, DexType synthesizingContext, DexItemFactory dexItemFactory) {
+ DexAnnotationElement kindElement =
+ new DexAnnotationElement(
+ dexItemFactory.kindString,
+ new DexValueString(dexItemFactory.createString(kind.descriptor)));
+ DexAnnotationElement typeElement =
+ new DexAnnotationElement(dexItemFactory.valueString, new DexValueType(synthesizingContext));
return new DexAnnotation(
VISIBILITY_BUILD,
new DexEncodedAnnotation(
- dexItemFactory.annotationSynthesizedClass, new DexAnnotationElement[] {element}));
+ dexItemFactory.annotationSynthesizedClass,
+ new DexAnnotationElement[] {kindElement, typeElement}));
}
public static boolean hasSynthesizedClassAnnotation(
@@ -413,7 +420,7 @@
return getSynthesizedClassAnnotationContextType(annotations, factory) != null;
}
- public static DexType getSynthesizedClassAnnotationContextType(
+ public static Pair<SyntheticKind, DexType> getSynthesizedClassAnnotationContextType(
DexAnnotationSet annotations, DexItemFactory factory) {
if (annotations.size() != 1) {
return null;
@@ -422,17 +429,31 @@
if (annotation.annotation.type != factory.annotationSynthesizedClass) {
return null;
}
- if (annotation.annotation.elements.length != 1) {
+ if (annotation.annotation.elements.length != 2) {
return null;
}
- DexAnnotationElement element = annotation.annotation.elements[0];
- if (element.name != factory.valueString) {
+ assert factory.kindString.isLessThan(factory.valueString);
+ DexAnnotationElement kindElement = annotation.annotation.elements[0];
+ if (kindElement.name != factory.kindString) {
return null;
}
- if (!element.value.isDexValueType()) {
+ if (!kindElement.value.isDexValueString()) {
return null;
}
- return element.value.asDexValueType().getValue();
+ SyntheticKind kind =
+ SyntheticNaming.SyntheticKind.fromDescriptor(
+ kindElement.value.asDexValueString().getValue().toString());
+ if (kind == null) {
+ return null;
+ }
+ DexAnnotationElement valueElement = annotation.annotation.elements[1];
+ if (valueElement.name != factory.valueString) {
+ return null;
+ }
+ if (!valueElement.value.isDexValueType()) {
+ return null;
+ }
+ return new Pair<>(kind, valueElement.value.asDexValueType().getValue());
}
public static DexAnnotation createAnnotationSynthesizedClassMap(
diff --git a/src/main/java/com/android/tools/r8/graph/DexApplication.java b/src/main/java/com/android/tools/r8/graph/DexApplication.java
index 6e38ed4..37b8d28 100644
--- a/src/main/java/com/android/tools/r8/graph/DexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DexApplication.java
@@ -18,6 +18,7 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
public abstract class DexApplication {
@@ -97,6 +98,8 @@
abstract List<DexProgramClass> programClasses();
+ abstract List<DexClasspathClass> classpathClasses();
+
public List<DexProgramClass> classes() {
ReorderBox<DexProgramClass> box = new ReorderBox<>(programClasses());
assert box.reorderClasses();
@@ -104,13 +107,16 @@
}
public List<DexProgramClass> classesWithDeterministicOrder() {
- List<DexProgramClass> classes = new ArrayList<>(programClasses());
- // We never actually sort by anything but the DexType, this is just here in case we ever change
- // that.
- if (options.testing.deterministicSortingBasedOnDexType) {
- // To keep the order deterministic, we sort the classes by their type, which is a unique key.
- classes.sort((a, b) -> a.type.compareTo(b.type));
- }
+ return classesWithDeterministicOrder(new ArrayList<>(programClasses()));
+ }
+
+ public static <T extends DexClass> List<T> classesWithDeterministicOrder(Collection<T> classes) {
+ return classesWithDeterministicOrder(new ArrayList<>(classes));
+ }
+
+ public static <T extends DexClass> List<T> classesWithDeterministicOrder(List<T> classes) {
+ // To keep the order deterministic, we sort the classes by their type, which is a unique key.
+ classes.sort(Comparator.comparing(DexClass::getType));
return classes;
}
@@ -126,14 +132,9 @@
}
public abstract static class Builder<T extends Builder<T>> {
- // We handle program class collection separately from classpath
- // and library class collections. Since while we assume program
- // class collection should always be fully loaded and thus fully
- // represented by the map (making it easy, for example, adding
- // new or removing existing classes), classpath and library
- // collections will be considered monolithic collections.
- final List<DexProgramClass> programClasses = new ArrayList<>();
+ private final List<DexProgramClass> programClasses = new ArrayList<>();
+ private final List<DexClasspathClass> classpathClasses = new ArrayList<>();
final List<DataResourceProvider> dataResourceProviders = new ArrayList<>();
@@ -156,6 +157,7 @@
public Builder(DexApplication application) {
programClasses.addAll(application.programClasses());
+ classpathClasses.addAll(application.classpathClasses());
dataResourceProviders.addAll(application.dataResourceProviders);
proguardMap = application.getProguardMap();
timing = application.timing;
@@ -171,13 +173,21 @@
return self();
}
- public synchronized T replaceProgramClasses(List<DexProgramClass> newProgramClasses) {
+ public synchronized T replaceProgramClasses(Collection<DexProgramClass> newProgramClasses) {
assert newProgramClasses != null;
this.programClasses.clear();
this.programClasses.addAll(newProgramClasses);
return self();
}
+ public synchronized T replaceClasspathClasses(
+ Collection<DexClasspathClass> newClasspathClasses) {
+ assert newClasspathClasses != null;
+ classpathClasses.clear();
+ classpathClasses.addAll(newClasspathClasses);
+ return self();
+ }
+
public synchronized T addDataResourceProvider(DataResourceProvider provider) {
dataResourceProviders.add(provider);
return self();
@@ -193,6 +203,21 @@
return self();
}
+ public synchronized T addProgramClasses(Collection<DexProgramClass> classes) {
+ programClasses.addAll(classes);
+ return self();
+ }
+
+ public synchronized T addClasspathClass(DexClasspathClass clazz) {
+ classpathClasses.add(clazz);
+ return self();
+ }
+
+ public synchronized T addClasspathClasses(Collection<DexClasspathClass> classes) {
+ classpathClasses.addAll(classes);
+ return self();
+ }
+
public synchronized T addSynthesizedClass(DexProgramClass synthesizedClass) {
assert synthesizedClass.isProgramClass() : "All synthesized classes must be program classes";
addProgramClass(synthesizedClass);
@@ -200,10 +225,14 @@
return self();
}
- public Collection<DexProgramClass> getProgramClasses() {
+ public List<DexProgramClass> getProgramClasses() {
return programClasses;
}
+ public List<DexClasspathClass> getClasspathClasses() {
+ return classpathClasses;
+ }
+
public Collection<DexProgramClass> getSynthesizedClasses() {
return synthesizedClasses;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java b/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
index d24a75b..60ab622 100644
--- a/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
+++ b/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
+import com.android.tools.r8.dex.Marker;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
import java.io.File;
@@ -10,6 +11,7 @@
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.List;
import java.util.function.Consumer;
public abstract class DexByteCodeWriter {
@@ -57,8 +59,12 @@
}
public void write(PrintStream output) throws IOException {
- write(x -> output, x -> {
- });
+ List<Marker> markers = application.dexItemFactory.extractMarkers();
+ System.out.println("Number of markers: " + markers.size());
+ for (Marker marker : markers) {
+ output.println(marker.toString());
+ }
+ write(x -> output, x -> {});
}
private void write(OutputStreamProvider outputStreamProvider, Consumer<PrintStream> closer)
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 22a830e..f1c0a2f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -122,6 +122,11 @@
}
}
+ public abstract void accept(
+ Consumer<DexProgramClass> programClassConsumer,
+ Consumer<DexClasspathClass> classpathClassConsumer,
+ Consumer<DexLibraryClass> libraryClassConsumer);
+
public void forEachClassMethod(Consumer<? super DexClassAndMethod> consumer) {
forEachClassMethodMatching(alwaysTrue(), consumer);
}
@@ -163,6 +168,10 @@
return Iterables.concat(fields(), methods());
}
+ public Iterable<DexEncodedMember<?, ?>> members(Predicate<DexEncodedMember<?, ?>> predicate) {
+ return Iterables.concat(fields(predicate), methods(predicate));
+ }
+
public MethodCollection getMethodCollection() {
return methodCollection;
}
@@ -171,7 +180,7 @@
return methodCollection.methods();
}
- public Iterable<DexEncodedMethod> methods(Predicate<DexEncodedMethod> predicate) {
+ public Iterable<DexEncodedMethod> methods(Predicate<? super DexEncodedMethod> predicate) {
return methodCollection.methods(predicate);
}
@@ -445,6 +454,15 @@
return field;
}
+ /** Find method in this class matching {@param method}. */
+ public DexClassAndField lookupClassField(DexField field) {
+ return toClassFieldOrNull(lookupField(field));
+ }
+
+ private DexClassAndField toClassFieldOrNull(DexEncodedField field) {
+ return field != null ? DexClassAndField.create(this, field) : null;
+ }
+
/** Find field in this class matching {@param field}. */
public DexEncodedField lookupField(DexField field) {
DexEncodedField result = lookupInstanceField(field);
@@ -848,6 +866,10 @@
nestHost = null;
}
+ public void clearNestMembers() {
+ nestMembers.clear();
+ }
+
public void setNestHost(DexType type) {
assert type != null;
this.nestHost = new NestHostClassAttribute(type);
@@ -887,6 +909,10 @@
/** Returns kotlin class info if the class is synthesized by kotlin compiler. */
public abstract KotlinClassLevelInfo getKotlinInfo();
+ public final String getTypeName() {
+ return getType().getTypeName();
+ }
+
public boolean hasStaticFields() {
return staticFields.length > 0;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
index bba0f82..cef86d0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
@@ -8,15 +8,20 @@
DexClassAndField(DexClass holder, DexEncodedField field) {
super(holder, field);
+ assert holder.isClasspathClass() == (this instanceof ClasspathField);
+ assert holder.isLibraryClass() == (this instanceof LibraryField);
assert holder.isProgramClass() == (this instanceof ProgramField);
}
public static DexClassAndField create(DexClass holder, DexEncodedField field) {
if (holder.isProgramClass()) {
return new ProgramField(holder.asProgramClass(), field);
- } else {
- return new DexClassAndField(holder, field);
}
+ if (holder.isLibraryClass()) {
+ return new LibraryField(holder.asLibraryClass(), field);
+ }
+ assert holder.isClasspathClass();
+ return new ClasspathField(holder.asClasspathClass(), field);
}
@Override
@@ -28,6 +33,22 @@
return getReference().getType();
}
+ public boolean isClasspathField() {
+ return false;
+ }
+
+ public ClasspathField asClasspathField() {
+ return null;
+ }
+
+ public boolean isLibraryField() {
+ return false;
+ }
+
+ public LibraryField asLibraryField() {
+ return null;
+ }
+
public boolean isProgramField() {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
index 719e2d6..83c4334 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
@@ -51,6 +51,18 @@
return holder.origin;
}
+ public boolean isClasspathMember() {
+ return false;
+ }
+
+ public boolean isLibraryMember() {
+ return false;
+ }
+
+ public boolean isProgramMember() {
+ return false;
+ }
+
public String toSourceString() {
return getReference().toSourceString();
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
index 0446e09..075c1ba 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
@@ -9,6 +9,8 @@
DexClassAndMethod(DexClass holder, DexEncodedMethod method) {
super(holder, method);
+ assert holder.isClasspathClass() == (this instanceof ClasspathMethod);
+ assert holder.isLibraryClass() == (this instanceof LibraryMethod);
assert holder.isProgramClass() == (this instanceof ProgramMethod);
}
@@ -19,12 +21,12 @@
public static DexClassAndMethod create(DexClass holder, DexEncodedMethod method) {
if (holder.isProgramClass()) {
return new ProgramMethod(holder.asProgramClass(), method);
- } else if (holder.isLibraryClass()) {
- return new LibraryMethod(holder.asLibraryClass(), method);
- } else {
- assert holder.isClasspathClass();
- return new ClasspathMethod(holder.asClasspathClass(), method);
}
+ if (holder.isLibraryClass()) {
+ return new LibraryMethod(holder.asLibraryClass(), method);
+ }
+ assert holder.isClasspathClass();
+ return new ClasspathMethod(holder.asClasspathClass(), method);
}
public boolean isDefaultMethod() {
diff --git a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
index c97a1a4..7fb6023 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
+import static com.google.common.base.Predicates.alwaysTrue;
+
import com.android.tools.r8.ProgramResource;
import com.android.tools.r8.ProgramResource.Kind;
import com.android.tools.r8.dex.MixedSectionCollection;
@@ -10,12 +12,17 @@
import com.android.tools.r8.graph.GenericSignature.ClassSignature;
import com.android.tools.r8.kotlin.KotlinClassLevelInfo;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.structural.StructuralItem;
+import com.android.tools.r8.utils.structural.StructuralMapping;
+import com.android.tools.r8.utils.structural.StructuralSpecification;
import java.util.List;
import java.util.Set;
+import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
-public class DexClasspathClass extends DexClass implements Supplier<DexClasspathClass> {
+public class DexClasspathClass extends DexClass
+ implements Supplier<DexClasspathClass>, StructuralItem<DexClasspathClass> {
public DexClasspathClass(
DexType type,
@@ -58,6 +65,24 @@
}
@Override
+ public void accept(
+ Consumer<DexProgramClass> programClassConsumer,
+ Consumer<DexClasspathClass> classpathClassConsumer,
+ Consumer<DexLibraryClass> libraryClassConsumer) {
+ classpathClassConsumer.accept(this);
+ }
+
+ public void forEachClasspathMethod(Consumer<? super ClasspathMethod> consumer) {
+ forEachClasspathMethodMatching(alwaysTrue(), consumer);
+ }
+
+ public void forEachClasspathMethodMatching(
+ Predicate<DexEncodedMethod> predicate, Consumer<? super ClasspathMethod> consumer) {
+ methodCollection.forEachMethodMatching(
+ predicate, method -> consumer.accept(new ClasspathMethod(this, method)));
+ }
+
+ @Override
public String toString() {
return type.toString() + "(classpath class)";
}
@@ -78,6 +103,10 @@
return this;
}
+ public static DexClasspathClass asClasspathClassOrNull(DexClass clazz) {
+ return clazz != null ? clazz.asClasspathClass() : null;
+ }
+
@Override
public boolean isNotProgramClass() {
return true;
@@ -104,4 +133,30 @@
}
return !isInterface() || appView.options().classpathInterfacesMayHaveStaticInitialization;
}
+
+ @Override
+ public DexClasspathClass self() {
+ return this;
+ }
+
+ @Override
+ public StructuralMapping<DexClasspathClass> getStructuralMapping() {
+ return DexClasspathClass::specify;
+ }
+
+ private static void specify(StructuralSpecification<DexClasspathClass, ?> spec) {
+ spec.withItem(DexClass::getType)
+ .withItem(DexClass::getSuperType)
+ .withItem(DexClass::getInterfaces)
+ .withItem(DexClass::getAccessFlags)
+ .withNullableItem(DexClass::getSourceFile)
+ .withNullableItem(DexClass::getNestHostClassAttribute)
+ .withItemCollection(DexClass::getNestMembersClassAttributes)
+ .withItem(DexDefinition::annotations)
+ // TODO(b/158159959): Make signatures structural.
+ .withAssert(c -> c.classSignature == ClassSignature.noSignature())
+ .withItemArray(c -> c.staticFields)
+ .withItemArray(c -> c.instanceFields)
+ .withItemCollection(DexClass::allMethodsSorted);
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index fc0eeb0..30d5cfd 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -203,10 +203,6 @@
return accessFlags.isPackagePrivate();
}
- public boolean isPrivate() {
- return accessFlags.isPrivate();
- }
-
public boolean isProtected() {
return accessFlags.isProtected();
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMember.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMember.java
index bca8a6b..d5c5135 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMember.java
@@ -35,6 +35,10 @@
return this;
}
+ public final boolean isPrivate() {
+ return getAccessFlags().isPrivate();
+ }
+
public abstract ProgramMember<D, R> asProgramMember(DexDefinitionSupplier definitions);
@Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 91203c8..fc56e08 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -49,7 +49,6 @@
import com.android.tools.r8.ir.code.NumericType;
import com.android.tools.r8.ir.code.ValueType;
import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring.DexFieldWithAccess;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.Inliner.Reason;
import com.android.tools.r8.ir.optimize.NestUtils;
@@ -60,7 +59,8 @@
import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
import com.android.tools.r8.ir.regalloc.RegisterAllocator;
import com.android.tools.r8.ir.synthetic.EmulateInterfaceSyntheticCfCodeProvider;
-import com.android.tools.r8.ir.synthetic.FieldAccessorSourceCode;
+import com.android.tools.r8.ir.synthetic.FieldAccessorBuilder;
+import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
import com.android.tools.r8.ir.synthetic.SynthesizedCode;
import com.android.tools.r8.kotlin.KotlinMethodLevelInfo;
@@ -76,14 +76,12 @@
import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.structural.CompareToVisitor;
-import com.android.tools.r8.utils.structural.CompareToVisitorWithTypeEquivalence;
import com.android.tools.r8.utils.structural.HashingVisitor;
-import com.android.tools.r8.utils.structural.HashingVisitorWithTypeEquivalence;
import com.android.tools.r8.utils.structural.Ordered;
-import com.android.tools.r8.utils.structural.RepresentativeMap;
+import com.android.tools.r8.utils.structural.StructuralItem;
+import com.android.tools.r8.utils.structural.StructuralMapping;
import com.android.tools.r8.utils.structural.StructuralSpecification;
import com.google.common.collect.ImmutableList;
-import com.google.common.hash.Hasher;
import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
import java.util.ArrayList;
@@ -95,7 +93,8 @@
import java.util.function.IntPredicate;
import org.objectweb.asm.Opcodes;
-public class DexEncodedMethod extends DexEncodedMember<DexEncodedMethod, DexMethod> {
+public class DexEncodedMethod extends DexEncodedMember<DexEncodedMethod, DexMethod>
+ implements StructuralItem<DexEncodedMethod> {
public static final String CONFIGURATION_DEBUGGING_PREFIX = "Shaking error: Missing method in ";
@@ -338,12 +337,22 @@
return deprecated;
}
+ @Override
+ public DexEncodedMethod self() {
+ return this;
+ }
+
+ @Override
+ public StructuralMapping<DexEncodedMethod> getStructuralMapping() {
+ return DexEncodedMethod::syntheticSpecify;
+ }
+
// Visitor specifying the structure of the method with respect to its "synthetic" content.
// TODO(b/171867022): Generalize this so that it determines any method in full.
private static void syntheticSpecify(StructuralSpecification<DexEncodedMethod, ?> spec) {
spec.withItem(m -> m.method)
.withItem(m -> m.accessFlags)
- .withItem(m -> m.annotations())
+ .withItem(DexDefinition::annotations)
.withItem(m -> m.parameterAnnotationsList)
.withNullableItem(m -> m.classFileVersion)
.withBool(m -> m.d8R8Synthesized)
@@ -356,28 +365,12 @@
DexEncodedMethod::hashCodeObject);
}
- public void hashSyntheticContent(Hasher hasher, RepresentativeMap map) {
- HashingVisitorWithTypeEquivalence.run(this, hasher, map, DexEncodedMethod::syntheticSpecify);
- }
-
- public boolean isSyntheticContentEqual(DexEncodedMethod other) {
- return syntheticCompareTo(other) == 0;
- }
-
- public int syntheticCompareTo(DexEncodedMethod other) {
- // Consider the holder types to be equivalent, using the holder of this method as the
- // representative.
- RepresentativeMap map = t -> t == other.getHolderType() ? getHolderType() : t;
- return CompareToVisitorWithTypeEquivalence.run(
- this, other, map, DexEncodedMethod::syntheticSpecify);
- }
-
private static int compareCodeObject(Code code1, Code code2, CompareToVisitor visitor) {
if (code1.isCfCode() && code2.isCfCode()) {
return code1.asCfCode().acceptCompareTo(code2.asCfCode(), visitor);
}
if (code1.isDexCode() && code2.isDexCode()) {
- return visitor.visit(code1.asDexCode(), code2.asDexCode(), DexCode::compareTo);
+ return code1.asDexCode().acceptCompareTo(code2.asDexCode(), visitor);
}
throw new Unreachable(
"Unexpected attempt to compare incompatible synthetic objects: " + code1 + " and " + code2);
@@ -387,14 +380,12 @@
if (code.isCfCode()) {
code.asCfCode().acceptHashing(visitor);
} else {
- // TODO(b/158159959): Implement a more precise hashing on code objects.
- assert code.isDexCode();
- visitor.visitInt(code.hashCode());
+ code.asDexCode().acceptHashing(visitor);
}
}
public DexProto getProto() {
- return getReference().proto;
+ return getReference().getProto();
}
@Override
@@ -411,10 +402,6 @@
return method.proto.parameters;
}
- public DexProto proto() {
- return method.proto;
- }
-
public DexType returnType() {
return method.proto.returnType;
}
@@ -506,10 +493,6 @@
return accessFlags.isNative();
}
- public boolean isPrivate() {
- return accessFlags.isPrivate();
- }
-
public boolean isPublic() {
return accessFlags.isPublic();
}
@@ -1016,6 +999,10 @@
}
public CfCode buildEmptyThrowingCfCode() {
+ return buildEmptyThrowingCfCode(method);
+ }
+
+ public static CfCode buildEmptyThrowingCfCode(DexMethod method) {
CfInstruction insn[] = {new CfConstNull(), new CfThrow()};
return new CfCode(
method.holder,
@@ -1201,59 +1188,47 @@
return builder.build();
}
- public ProgramMethod toInitializerForwardingBridge(DexProgramClass holder, DexMethod newMethod) {
- assert accessFlags.isPrivate()
+ public ProgramMethod toInitializerForwardingBridge(
+ DexProgramClass holder, DexMethod newMethod, DexItemFactory dexItemFactory) {
+ assert isPrivate()
: "Expected to create bridge for private constructor as part of nest-based access"
+ " desugaring";
- Builder builder = syntheticBuilder(this);
- builder.setMethod(newMethod);
- ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
- ForwardMethodSourceCode.builder(newMethod);
- forwardSourceCodeBuilder
- .setReceiver(holder.type)
- .setTargetReceiver(holder.type)
- .setTarget(method)
- .setInvokeType(Invoke.Type.DIRECT)
- .setExtraNullParameter();
- builder.setCode(
- new SynthesizedCode(
- forwardSourceCodeBuilder::build, registry -> registry.registerInvokeDirect(method)));
- assert !builder.accessFlags.isStatic();
assert !holder.isInterface();
- builder.accessFlags.unsetPrivate();
- builder.accessFlags.setSynthetic();
- builder.accessFlags.setConstructor();
- return new ProgramMethod(holder, builder.build());
+ return new ProgramMethod(
+ holder,
+ syntheticBuilder(this)
+ .setMethod(newMethod)
+ .setCode(
+ ForwardMethodBuilder.builder(dexItemFactory)
+ .setNonStaticSourceWithExtraUnusedParameter(newMethod)
+ .setConstructorTarget(getReference())
+ .build())
+ .modifyAccessFlags(
+ accessFlags -> {
+ assert !accessFlags.isStatic();
+ accessFlags.unsetPrivate();
+ accessFlags.setSynthetic();
+ accessFlags.setConstructor();
+ })
+ .build());
}
public static ProgramMethod createFieldAccessorBridge(
- DexFieldWithAccess fieldWithAccess, DexProgramClass holder, DexMethod newMethod) {
- assert holder.type == fieldWithAccess.getHolder();
+ ProgramField field, boolean isGet, DexMethod newMethod) {
MethodAccessFlags accessFlags =
MethodAccessFlags.fromSharedAccessFlags(
Constants.ACC_SYNTHETIC
| Constants.ACC_STATIC
- | (holder.isInterface() ? Constants.ACC_PUBLIC : 0),
+ | (field.getHolder().isInterface() ? Constants.ACC_PUBLIC : 0),
false);
- Code code =
- new SynthesizedCode(
- callerPosition ->
- new FieldAccessorSourceCode(
- null, newMethod, callerPosition, newMethod, fieldWithAccess),
- registry -> {
- if (fieldWithAccess.isInstanceGet()) {
- registry.registerInstanceFieldRead(fieldWithAccess.getField());
- } else if (fieldWithAccess.isStaticGet()) {
- registry.registerStaticFieldRead(fieldWithAccess.getField());
- } else if (fieldWithAccess.isInstancePut()) {
- registry.registerInstanceFieldWrite(fieldWithAccess.getField());
- } else {
- assert fieldWithAccess.isStaticPut();
- registry.registerStaticFieldWrite(fieldWithAccess.getField());
- }
- });
+ CfCode code =
+ FieldAccessorBuilder.builder()
+ .apply(isGet ? FieldAccessorBuilder::setGetter : FieldAccessorBuilder::setSetter)
+ .setField(field)
+ .setSourceMethod(newMethod)
+ .build();
return new ProgramMethod(
- holder,
+ field.getHolder(),
new DexEncodedMethod(
newMethod,
accessFlags,
@@ -1294,35 +1269,36 @@
true);
}
- public ProgramMethod toStaticForwardingBridge(DexProgramClass holder, DexMethod newMethod) {
- assert accessFlags.isPrivate()
+ public ProgramMethod toStaticForwardingBridge(
+ DexProgramClass holder, DexMethod newMethod, DexItemFactory dexItemFactory) {
+ assert isPrivate()
: "Expected to create bridge for private method as part of nest-based access desugaring";
- Builder builder = syntheticBuilder(this);
- builder.setMethod(newMethod);
- ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
- ForwardMethodSourceCode.builder(newMethod);
- forwardSourceCodeBuilder
- .setTargetReceiver(accessFlags.isStatic() ? null : method.holder)
- .setTarget(method)
- .setInvokeType(accessFlags.isStatic() ? Invoke.Type.STATIC : Invoke.Type.DIRECT)
- .setIsInterface(holder.isInterface());
- builder.setCode(
- new SynthesizedCode(
- forwardSourceCodeBuilder::build,
- registry -> {
- if (accessFlags.isStatic()) {
- registry.registerInvokeStatic(method);
- } else {
- registry.registerInvokeDirect(method);
- }
- }));
- builder.accessFlags.setSynthetic();
- builder.accessFlags.setStatic();
- builder.accessFlags.unsetPrivate();
- if (holder.isInterface()) {
- builder.accessFlags.setPublic();
- }
- return new ProgramMethod(holder, builder.build());
+ return new ProgramMethod(
+ holder,
+ syntheticBuilder(this)
+ .setMethod(newMethod)
+ .setCode(
+ ForwardMethodBuilder.builder(dexItemFactory)
+ .setStaticSource(newMethod)
+ .apply(
+ builder -> {
+ if (isStatic()) {
+ builder.setStaticTarget(getReference(), holder.isInterface());
+ } else {
+ builder.setDirectTarget(getReference(), holder.isInterface());
+ }
+ })
+ .build())
+ .modifyAccessFlags(
+ accessFlags -> {
+ accessFlags.setSynthetic();
+ accessFlags.setStatic();
+ accessFlags.unsetPrivate();
+ if (holder.isInterface()) {
+ accessFlags.setPublic();
+ }
+ })
+ .build());
}
public DexEncodedMethod toPrivateSyntheticMethod(DexMethod method) {
@@ -1596,12 +1572,18 @@
return this;
}
+ public Builder modifyAccessFlags(Consumer<MethodAccessFlags> consumer) {
+ consumer.accept(accessFlags);
+ return this;
+ }
+
public void setAccessFlags(MethodAccessFlags accessFlags) {
this.accessFlags = accessFlags.copy();
}
- public void setMethod(DexMethod method) {
+ public Builder setMethod(DexMethod method) {
this.method = method;
+ return this;
}
public Builder setCompilationState(CompilationState compilationState) {
@@ -1686,8 +1668,9 @@
return this;
}
- public void setCode(Code code) {
+ public Builder setCode(Code code) {
this.code = code;
+ return this;
}
public DexEncodedMethod build() {
diff --git a/src/main/java/com/android/tools/r8/graph/DexField.java b/src/main/java/com/android/tools/r8/graph/DexField.java
index e9c2fc5..a925fcc 100644
--- a/src/main/java/com/android/tools/r8/graph/DexField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexField.java
@@ -52,6 +52,11 @@
}
@Override
+ public DexClassAndField lookupMemberOnClass(DexClass clazz) {
+ return clazz != null ? clazz.lookupClassField(this) : null;
+ }
+
+ @Override
public ProgramField lookupOnProgramClass(DexProgramClass clazz) {
return clazz != null ? clazz.lookupProgramField(this) : null;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index e6d824a..fd33483 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.graph;
import static com.android.tools.r8.ir.analysis.type.ClassTypeElement.computeLeastUpperBoundOfInterfaces;
-import static com.android.tools.r8.ir.optimize.ServiceLoaderRewriter.SERVICE_LOADER_CLASS_NAME;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.dex.Marker;
@@ -20,12 +19,13 @@
import com.android.tools.r8.graph.DexMethodHandle.MethodHandleType;
import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.ReferenceTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring;
+import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.utils.ArrayUtils;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -44,7 +44,6 @@
import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
@@ -90,9 +89,9 @@
// ReferenceTypeElement canonicalization.
private final ConcurrentHashMap<DexType, ReferenceTypeElement> referenceTypes =
new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexType, Set<DexType>> classTypeInterfaces =
+ private final ConcurrentHashMap<DexType, InterfaceCollection> classTypeInterfaces =
new ConcurrentHashMap<>();
- public final LRUCacheTable<Set<DexType>, Set<DexType>, Set<DexType>>
+ public final LRUCacheTable<InterfaceCollection, InterfaceCollection, InterfaceCollection>
leastUpperBoundOfInterfacesTable = LRUCacheTable.create(8, 8);
boolean sorted = false;
@@ -231,6 +230,8 @@
public final DexString iterableDescriptor = createString("Ljava/lang/Iterable;");
public final DexString mathDescriptor = createString("Ljava/lang/Math;");
public final DexString strictMathDescriptor = createString("Ljava/lang/StrictMath;");
+ public final DexString closeableDescriptor = createString("Ljava/io/Closeable;");
+ public final DexString zipFileDescriptor = createString("Ljava/util/zip/ZipFile;");
public final DexString stringBuilderDescriptor = createString("Ljava/lang/StringBuilder;");
public final DexString stringBufferDescriptor = createString("Ljava/lang/StringBuffer;");
@@ -292,6 +293,11 @@
createString(Constants.TEMPORARY_INSTANCE_INITIALIZER_PREFIX);
public final DexString thisName = createString("this");
+
+ // As much as possible, R8 should rely on the content of the static enum field, using
+ // enumMembers.isValuesFieldCandidate or checking the object state in the optimization info.
+ // The field name is unrealiable since the filed can be minified prior to this compilation.
+ // We keep enumValuesFieldName as a heuristic only.
public final DexString enumValuesFieldName = createString("$VALUES");
public final DexString enabledFieldName = createString("ENABLED");
@@ -299,6 +305,7 @@
public final DexString throwableArrayDescriptor = createString("[Ljava/lang/Throwable;");
public final DexString valueString = createString("value");
+ public final DexString kindString = createString("kind");
public final DexType booleanType = createStaticallyKnownType(booleanDescriptor);
public final DexType byteType = createStaticallyKnownType(byteDescriptor);
@@ -356,6 +363,9 @@
public final DexType methodType = createStaticallyKnownType(methodDescriptor);
public final DexType autoCloseableType = createStaticallyKnownType(autoCloseableDescriptor);
+ public final DexType closeableType = createStaticallyKnownType(closeableDescriptor);
+ public final DexType zipFileType = createStaticallyKnownType(zipFileDescriptor);
+
public final DexType stringBuilderType = createStaticallyKnownType(stringBuilderDescriptor);
public final DexType stringBufferType = createStaticallyKnownType(stringBufferDescriptor);
@@ -369,8 +379,6 @@
createStaticallyKnownType(invocationHandlerDescriptor);
public final DexType proxyType = createStaticallyKnownType(proxyDescriptor);
public final DexType serviceLoaderType = createStaticallyKnownType(serviceLoaderDescriptor);
- public final DexType serviceLoaderRewrittenClassType =
- createStaticallyKnownType("L" + SERVICE_LOADER_CLASS_NAME + ";");
public final DexType serviceLoaderConfigurationErrorType =
createStaticallyKnownType(serviceLoaderConfigurationErrorDescriptor);
public final DexType listType = createStaticallyKnownType(listDescriptor);
@@ -409,6 +417,8 @@
public final DexType noClassDefFoundErrorType =
createStaticallyKnownType(noClassDefFoundErrorDescriptor);
public final DexType noSuchFieldErrorType = createStaticallyKnownType(noSuchFieldErrorDescriptor);
+ public final DexType noSuchMethodErrorType =
+ createStaticallyKnownType("Ljava/lang/NoSuchMethodError;");
public final DexType npeType = createStaticallyKnownType(npeDescriptor);
public final DexType reflectiveOperationExceptionType =
createStaticallyKnownType(reflectiveOperationExceptionDescriptor);
@@ -1380,21 +1390,17 @@
return field == nameField || field == ordinalField;
}
- public boolean isValuesMethod(DexMethod method, DexClass enumClass) {
- assert enumClass.isEnum();
- return method.holder == enumClass.type
- && method.proto.returnType == enumClass.type.toArrayType(1, DexItemFactory.this)
- && method.proto.parameters.size() == 0
- && method.name == valuesMethodName;
+ public boolean isEnumField(DexEncodedField staticField, DexType enumType) {
+ assert staticField.isStatic();
+ return staticField.getType() == enumType && staticField.isEnum() && staticField.isFinal();
}
- public boolean isValueOfMethod(DexMethod method, DexClass enumClass) {
- assert enumClass.isEnum();
- return method.holder == enumClass.type
- && method.proto.returnType == enumClass.type
- && method.proto.parameters.size() == 1
- && method.proto.parameters.values[0] == stringType
- && method.name == valueOfMethodName;
+ public boolean isValuesFieldCandidate(DexEncodedField staticField, DexType enumType) {
+ assert staticField.isStatic();
+ return staticField.getType().isArrayType()
+ && staticField.getType().toArrayElementType(DexItemFactory.this) == enumType
+ && staticField.isSynthetic()
+ && staticField.isFinal();
}
}
@@ -2420,12 +2426,12 @@
if (type.isClassType()) {
if (!appView.enableWholeProgramOptimizations()) {
// Don't reason at the level of interfaces in D8.
- return ClassTypeElement.create(type, nullability, Collections.emptySet());
+ return ClassTypeElement.create(type, nullability, InterfaceCollection.empty());
}
assert appView.appInfo().hasClassHierarchy();
if (appView.isInterface(type).isTrue()) {
return ClassTypeElement.create(
- objectType, nullability, Collections.singleton(type));
+ objectType, nullability, InterfaceCollection.singleton(type));
}
// In theory, `interfaces` is the least upper bound of implemented interfaces.
// It is expensive to walk through type hierarchy; collect implemented interfaces;
@@ -2440,12 +2446,12 @@
.getOrCreateVariant(nullability);
}
- public Set<DexType> getOrComputeLeastUpperBoundOfImplementedInterfaces(
+ public InterfaceCollection getOrComputeLeastUpperBoundOfImplementedInterfaces(
DexType type, AppView<? extends AppInfoWithClassHierarchy> appView) {
return classTypeInterfaces.computeIfAbsent(
type,
t -> {
- Set<DexType> itfs = appView.appInfo().implementedInterfaces(t);
+ InterfaceCollection itfs = appView.appInfo().implementedInterfaces(t);
return computeLeastUpperBoundOfInterfaces(appView, itfs, itfs);
});
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
index e5a8097..df36fb7 100644
--- a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
@@ -13,6 +13,7 @@
import java.util.Arrays;
import java.util.List;
import java.util.Set;
+import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
@@ -85,6 +86,14 @@
}
@Override
+ public void accept(
+ Consumer<DexProgramClass> programClassConsumer,
+ Consumer<DexClasspathClass> classpathClassConsumer,
+ Consumer<DexLibraryClass> libraryClassConsumer) {
+ libraryClassConsumer.accept(this);
+ }
+
+ @Override
public String toString() {
return type.toString() + "(library class)";
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexMember.java b/src/main/java/com/android/tools/r8/graph/DexMember.java
index 1c02f3b..9b62855 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMember.java
@@ -24,6 +24,8 @@
public abstract DexEncodedMember<?, ?> lookupOnClass(DexClass clazz);
+ public abstract DexClassAndMember<?, ?> lookupMemberOnClass(DexClass clazz);
+
public abstract ProgramMember<?, ?> lookupOnProgramClass(DexProgramClass clazz);
public abstract boolean match(R entry);
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index d35b1a0..29e9792 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -102,6 +102,11 @@
}
@Override
+ public DexClassAndMethod lookupMemberOnClass(DexClass clazz) {
+ return clazz != null ? clazz.lookupClassMethod(this) : null;
+ }
+
+ @Override
public ProgramMethod lookupOnProgramClass(DexProgramClass clazz) {
return clazz != null ? clazz.lookupProgramMethod(this) : null;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 2a6ebf5..618ff5b 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -21,6 +21,9 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.TraversalContinuation;
import com.android.tools.r8.utils.structural.Ordered;
+import com.android.tools.r8.utils.structural.StructuralItem;
+import com.android.tools.r8.utils.structural.StructuralMapping;
+import com.android.tools.r8.utils.structural.StructuralSpecification;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
@@ -37,7 +40,7 @@
import java.util.function.Supplier;
public class DexProgramClass extends DexClass
- implements ProgramDefinition, Supplier<DexProgramClass> {
+ implements ProgramDefinition, Supplier<DexProgramClass>, StructuralItem<DexProgramClass> {
@FunctionalInterface
public interface ChecksumSupplier {
@@ -144,6 +147,44 @@
synthesizedDirectlyFrom.forEach(this::addSynthesizedFrom);
}
+ @Override
+ public void accept(
+ Consumer<DexProgramClass> programClassConsumer,
+ Consumer<DexClasspathClass> classpathClassConsumer,
+ Consumer<DexLibraryClass> libraryClassConsumer) {
+ programClassConsumer.accept(this);
+ }
+
+ @Override
+ public DexProgramClass self() {
+ return this;
+ }
+
+ @Override
+ public StructuralMapping<DexProgramClass> getStructuralMapping() {
+ return DexProgramClass::specify;
+ }
+
+ private static void specify(StructuralSpecification<DexProgramClass, ?> spec) {
+ spec.withItem(c -> c.type)
+ .withItem(c -> c.superType)
+ .withItem(c -> c.interfaces)
+ .withItem(c -> c.accessFlags)
+ .withNullableItem(c -> c.sourceFile)
+ .withNullableItem(c -> c.initialClassFileVersion)
+ .withBool(c -> c.deprecated)
+ .withNullableItem(DexClass::getNestHostClassAttribute)
+ .withItemCollection(DexClass::getNestMembersClassAttributes)
+ .withItem(DexDefinition::annotations)
+ // TODO(b/158159959): Make signatures structural.
+ .withAssert(c -> c.classSignature == ClassSignature.noSignature())
+ .withItemArray(c -> c.staticFields)
+ .withItemArray(c -> c.instanceFields)
+ .withItemCollection(DexClass::allMethodsSorted)
+ // TODO(b/168584485): Synthesized-from is being removed (empty for new synthetics).
+ .withAssert(c -> c.synthesizedFrom.isEmpty());
+ }
+
public void forEachProgramField(Consumer<? super ProgramField> consumer) {
forEachField(field -> consumer.accept(new ProgramField(this, field)));
}
@@ -171,6 +212,15 @@
return Iterables.transform(directMethods(predicate), method -> new ProgramMethod(this, method));
}
+ public Iterable<ProgramMethod> virtualProgramMethods() {
+ return Iterables.transform(virtualMethods(), method -> new ProgramMethod(this, method));
+ }
+
+ public Iterable<ProgramMethod> virtualProgramMethods(Predicate<DexEncodedMethod> predicate) {
+ return Iterables.transform(
+ virtualMethods(predicate), method -> new ProgramMethod(this, method));
+ }
+
public Iterable<ProgramMethod> programInstanceInitializers() {
return directProgramMethods(DexEncodedMethod::isInstanceInitializer);
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 27284ea..56f9a92 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -8,7 +8,6 @@
import static com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer.VIVIFIED_TYPE_WRAPPER_SUFFIX;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
-import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_GROUP_CLASS_NAME_PREFIX;
import static com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX;
@@ -16,11 +15,9 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.horizontalclassmerging.SyntheticArgumentClass;
import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
-import com.android.tools.r8.ir.optimize.ServiceLoaderRewriter;
+import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
import com.android.tools.r8.utils.structural.CompareToVisitor;
@@ -41,7 +38,13 @@
// Bundletool is merging classes that may originate from a build with an old version of R8.
// Allow merging of classes that use names from older versions of R8.
private static List<String> OLD_SYNTHESIZED_NAMES =
- ImmutableList.of("$r8$backportedMethods$utility", "$r8$java8methods$utility", "$-DC");
+ ImmutableList.of(
+ "$r8$backportedMethods$utility",
+ "$r8$java8methods$utility",
+ "$r8$twr$utility",
+ "$-DC",
+ "$$ServiceLoaderMethods",
+ "-$$Lambda$");
public final DexString descriptor;
private String toStringCache = null;
@@ -172,6 +175,10 @@
classConsumer.accept(this, arg);
}
+ public String getTypeName() {
+ return toSourceString();
+ }
+
@Override
public String toSourceString() {
if (toStringCache == null) {
@@ -302,12 +309,6 @@
}
// TODO(b/158159959): Remove usage of name-based identification.
- public boolean isD8R8SynthesizedLambdaClassType() {
- String name = toSourceString();
- return name.contains(LAMBDA_CLASS_NAME_PREFIX);
- }
-
- // TODO(b/158159959): Remove usage of name-based identification.
public boolean isD8R8SynthesizedClassType() {
String name = toSourceString();
// The synthesized classes listed here must always be unique to a program context and thus
@@ -318,8 +319,7 @@
|| name.contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)
|| name.contains(SyntheticArgumentClass.SYNTHETIC_CLASS_SUFFIX)
// New and hygienic synthesis infrastructure.
- || name.contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
- || name.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
+ || SyntheticNaming.isSyntheticName(name)
// Only generated in core lib.
|| name.contains(EMULATE_LIBRARY_CLASS_NAME_SUFFIX)
|| name.contains(TYPE_WRAPPER_SUFFIX)
@@ -337,12 +337,9 @@
private static boolean isSynthesizedTypeThatCouldBeDuplicated(String name) {
// Any entry that is removed from here must be added to OLD_SYNTHESIZED_NAMES to ensure that
// newer releases can be used to merge previous builds.
- return name.contains(LAMBDA_CLASS_NAME_PREFIX) // Could collide.
- || name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
+ return name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
|| name.contains(OutlineOptions.CLASS_NAME) // Global singleton.
- || name.contains(TwrCloseResourceRewriter.UTILITY_CLASS_NAME) // Global singleton.
- || name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME) // Global singleton.
- || name.contains(ServiceLoaderRewriter.SERVICE_LOADER_CLASS_NAME); // Global singleton.
+ || name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME); // Global singleton.
}
private boolean oldSynthesizedName(String name) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexTypeList.java b/src/main/java/com/android/tools/r8/graph/DexTypeList.java
index 076322a..07410c0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexTypeList.java
+++ b/src/main/java/com/android/tools/r8/graph/DexTypeList.java
@@ -54,6 +54,10 @@
return values.isEmpty() ? DexTypeList.empty() : new DexTypeList(values);
}
+ public DexType get(int index) {
+ return values[index];
+ }
+
public DexTypeList keepIf(Predicate<DexType> predicate) {
DexType[] filtered = ArrayUtils.filter(DexType[].class, values, predicate);
if (filtered != values) {
diff --git a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
index 5a7d18f..4f38fb2 100644
--- a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
@@ -63,11 +63,12 @@
return programClasses;
}
- public Collection<DexLibraryClass> libraryClasses() {
+ public List<DexLibraryClass> libraryClasses() {
return libraryClasses;
}
- public Collection<DexClasspathClass> classpathClasses() {
+ @Override
+ public List<DexClasspathClass> classpathClasses() {
return classpathClasses;
}
@@ -181,21 +182,19 @@
public static class Builder extends DexApplication.Builder<Builder> {
private ImmutableList<DexLibraryClass> libraryClasses;
- private ImmutableList<DexClasspathClass> classpathClasses;
Builder(LazyLoadedDexApplication application) {
super(application);
// As a side-effect, this will force-load all classes.
AllClasses allClasses = application.loadAllClasses();
libraryClasses = allClasses.getLibraryClasses();
- classpathClasses = allClasses.getClasspathClasses();
replaceProgramClasses(allClasses.getProgramClasses());
+ replaceClasspathClasses(allClasses.getClasspathClasses());
}
private Builder(DirectMappedDexApplication application) {
super(application);
libraryClasses = application.libraryClasses;
- classpathClasses = application.classpathClasses;
}
@Override
@@ -208,20 +207,6 @@
return self();
}
- public Builder replaceClasspathClasses(Collection<DexClasspathClass> classpathClasses) {
- this.classpathClasses = ImmutableList.copyOf(classpathClasses);
- return self();
- }
-
- public Builder addClasspathClasses(Collection<DexClasspathClass> classes) {
- classpathClasses =
- ImmutableList.<DexClasspathClass>builder()
- .addAll(classpathClasses)
- .addAll(classes)
- .build();
- return self();
- }
-
public Builder addLibraryClasses(Collection<DexLibraryClass> classes) {
libraryClasses =
ImmutableList.<DexLibraryClass>builder().addAll(libraryClasses).addAll(classes).build();
@@ -234,17 +219,17 @@
// TODO(zerny): Consider not rebuilding the map if no program classes are added.
Map<DexType, DexClass> allClasses =
new IdentityHashMap<>(
- programClasses.size() + classpathClasses.size() + libraryClasses.size());
+ getProgramClasses().size() + getClasspathClasses().size() + libraryClasses.size());
// Note: writing classes in reverse priority order, so a duplicate will be correctly ordered.
// There should never be duplicates and that is asserted in the addAll subroutine.
addAll(allClasses, libraryClasses);
- addAll(allClasses, classpathClasses);
- addAll(allClasses, programClasses);
+ addAll(allClasses, getClasspathClasses());
+ addAll(allClasses, getProgramClasses());
return new DirectMappedDexApplication(
proguardMap,
allClasses,
- ImmutableList.copyOf(programClasses),
- classpathClasses,
+ ImmutableList.copyOf(getProgramClasses()),
+ ImmutableList.copyOf(getClasspathClasses()),
libraryClasses,
ImmutableList.copyOf(dataResourceProviders),
options,
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLens.java b/src/main/java/com/android/tools/r8/graph/GraphLens.java
index 0e3d784..ca9a57a 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLens.java
@@ -5,7 +5,6 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.horizontalclassmerging.ClassMerger.CLASS_ID_FIELD_NAME;
-import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_INSTANCE_FIELD_NAME;
import com.android.tools.r8.errors.Unreachable;
@@ -573,6 +572,14 @@
return builder.build();
}
+ public ImmutableSet<DexField> rewriteFields(Set<DexField> fields) {
+ ImmutableSet.Builder<DexField> builder = ImmutableSet.builder();
+ for (DexField field : fields) {
+ builder.add(getRenamedFieldSignature(field));
+ }
+ return builder.build();
+ }
+
public <T> ImmutableMap<DexField, T> rewriteFieldKeys(Map<DexField, T> map) {
ImmutableMap.Builder<DexField, T> builder = ImmutableMap.builder();
map.forEach((field, value) -> builder.put(getRenamedFieldSignature(field), value));
@@ -620,7 +627,7 @@
// that they can be mapped back to the original program.
DexField originalField = getOriginalFieldSignature(field.getReference());
assert originalFields.contains(originalField)
- || isD8R8SynthesizedField(originalField, dexItemFactory)
+ || isD8R8SynthesizedField(originalField, appView)
: "Unable to map field `"
+ field.getReference().toSourceString()
+ "` back to original program";
@@ -638,16 +645,16 @@
return true;
}
- private boolean isD8R8SynthesizedField(DexField field, DexItemFactory dexItemFactory) {
+ private boolean isD8R8SynthesizedField(DexField field, AppView<?> appView) {
// TODO(b/167947782): Should be a general check to see if the field is D8/R8 synthesized
// instead of relying on field names.
- if (field.match(dexItemFactory.objectMembers.clinitField)) {
+ if (field.match(appView.dexItemFactory().objectMembers.clinitField)) {
return true;
}
if (field.getName().toSourceString().equals(CLASS_ID_FIELD_NAME)) {
return true;
}
- if (field.getHolderType().toSourceString().contains(LAMBDA_CLASS_NAME_PREFIX)
+ if (appView.getSyntheticItems().isSyntheticClass(field.getHolderType())
&& field.getName().toSourceString().equals(LAMBDA_INSTANCE_FIELD_NAME)) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
index 88596f9..40b6445 100644
--- a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
+++ b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
@@ -817,8 +817,7 @@
private boolean classRequiresCode() {
return parent.classKind == ClassKind.PROGRAM
- || (parent.application.options.enableNestBasedAccessDesugaring
- && !parent.application.options.canUseNestBasedAccess()
+ || (!parent.application.options.canUseNestBasedAccess()
&& parent.classKind == ClassKind.CLASSPATH
&& parent.isInANest());
}
diff --git a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
index 6a70cdd..ba22b16 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
@@ -105,7 +105,7 @@
private final Origin origin;
private JarApplicationReader application;
private CfCode code;
- protected ReparseContext context;
+ private ReparseContext context;
private boolean reachabilitySensitive = false;
public void markReachabilitySensitive() {
diff --git a/src/main/java/com/android/tools/r8/graph/LazyLoadedDexApplication.java b/src/main/java/com/android/tools/r8/graph/LazyLoadedDexApplication.java
index ce5ff83..ba240f6 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyLoadedDexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyLoadedDexApplication.java
@@ -54,6 +54,12 @@
}
@Override
+ List<DexClasspathClass> classpathClasses() {
+ classpathClasses.forceLoad(t -> true);
+ return classpathClasses.getAllClasses();
+ }
+
+ @Override
public DexClass definitionFor(DexType type) {
assert type.isClassType() : "Cannot lookup definition for type: " + type;
DexClass clazz = null;
@@ -199,7 +205,7 @@
Builder(ProgramClassConflictResolver resolver, InternalOptions options, Timing timing) {
super(options, timing);
this.resolver = resolver;
- this.classpathClasses = null;
+ this.classpathClasses = ClasspathClassCollection.empty();
this.libraryClasses = null;
}
@@ -229,7 +235,7 @@
public LazyLoadedDexApplication build() {
return new LazyLoadedDexApplication(
proguardMap,
- ProgramClassCollection.create(programClasses, resolver),
+ ProgramClassCollection.create(getProgramClasses(), resolver),
ImmutableList.copyOf(dataResourceProviders),
classpathClasses,
libraryClasses,
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryField.java b/src/main/java/com/android/tools/r8/graph/LibraryField.java
new file mode 100644
index 0000000..49ed565
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/LibraryField.java
@@ -0,0 +1,35 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+public class LibraryField extends DexClassAndField
+ implements LibraryMember<DexEncodedField, DexField> {
+
+ public LibraryField(DexLibraryClass holder, DexEncodedField field) {
+ super(holder, field);
+ }
+
+ @Override
+ public DexLibraryClass getHolder() {
+ DexClass holder = super.getHolder();
+ assert holder.isLibraryClass();
+ return holder.asLibraryClass();
+ }
+
+ @Override
+ public boolean isLibraryField() {
+ return true;
+ }
+
+ @Override
+ public LibraryField asLibraryField() {
+ return this;
+ }
+
+ @Override
+ public boolean isLibraryMember() {
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryMember.java b/src/main/java/com/android/tools/r8/graph/LibraryMember.java
new file mode 100644
index 0000000..880da78
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/LibraryMember.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+public interface LibraryMember<D extends DexEncodedMember<D, R>, R extends DexMember<D, R>> {
+
+ D getDefinition();
+
+ DexLibraryClass getHolder();
+
+ DexType getHolderType();
+}
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryMethod.java b/src/main/java/com/android/tools/r8/graph/LibraryMethod.java
index c06ebab..29cdc41 100644
--- a/src/main/java/com/android/tools/r8/graph/LibraryMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/LibraryMethod.java
@@ -4,13 +4,26 @@
package com.android.tools.r8.graph;
/** Type representing a method definition from the library and its holder. */
-public final class LibraryMethod extends DexClassAndMethod {
+public final class LibraryMethod extends DexClassAndMethod
+ implements LibraryMember<DexEncodedMethod, DexMethod> {
public LibraryMethod(DexLibraryClass holder, DexEncodedMethod method) {
super(holder, method);
}
@Override
+ public DexLibraryClass getHolder() {
+ DexClass holder = super.getHolder();
+ assert holder.isLibraryClass();
+ return holder.asLibraryClass();
+ }
+
+ @Override
+ public boolean isLibraryMember() {
+ return true;
+ }
+
+ @Override
public boolean isLibraryMethod() {
return true;
}
@@ -19,11 +32,4 @@
public LibraryMethod asLibraryMethod() {
return this;
}
-
- @Override
- public DexLibraryClass getHolder() {
- DexClass holder = super.getHolder();
- assert holder.isLibraryClass();
- return holder.asLibraryClass();
- }
}
diff --git a/src/main/java/com/android/tools/r8/graph/MethodCollection.java b/src/main/java/com/android/tools/r8/graph/MethodCollection.java
index 9339630..ccf33aa 100644
--- a/src/main/java/com/android/tools/r8/graph/MethodCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/MethodCollection.java
@@ -130,7 +130,7 @@
return backing.methods();
}
- public Iterable<DexEncodedMethod> methods(Predicate<DexEncodedMethod> predicate) {
+ public Iterable<DexEncodedMethod> methods(Predicate<? super DexEncodedMethod> predicate) {
return IterableUtils.filter(methods(), predicate);
}
diff --git a/src/main/java/com/android/tools/r8/graph/MethodMapBacking.java b/src/main/java/com/android/tools/r8/graph/MethodMapBacking.java
index c6f7a5f..f3385af 100644
--- a/src/main/java/com/android/tools/r8/graph/MethodMapBacking.java
+++ b/src/main/java/com/android/tools/r8/graph/MethodMapBacking.java
@@ -34,7 +34,7 @@
}
public static MethodMapBacking createSorted() {
- Comparator<Wrapper<DexMethod>> comparator = (x, y) -> x.get().compareTo(y.get());
+ Comparator<Wrapper<DexMethod>> comparator = Comparator.comparing(Wrapper::get);
return new MethodMapBacking(new Object2ReferenceRBTreeMap<>(comparator));
}
diff --git a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
index e007f4e..c9969a6 100644
--- a/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestHostClassAttribute.java
@@ -5,12 +5,19 @@
package com.android.tools.r8.graph;
import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.utils.structural.StructuralItem;
+import com.android.tools.r8.utils.structural.StructuralMapping;
+import com.android.tools.r8.utils.structural.StructuralSpecification;
import org.objectweb.asm.ClassWriter;
-public class NestHostClassAttribute {
+public class NestHostClassAttribute implements StructuralItem<NestHostClassAttribute> {
private final DexType nestHost;
+ private static void specify(StructuralSpecification<NestHostClassAttribute, ?> spec) {
+ spec.withItem(a -> a.nestHost);
+ }
+
public NestHostClassAttribute(DexType nestHost) {
this.nestHost = nestHost;
}
@@ -27,4 +34,14 @@
assert nestHost != null;
writer.visitNestHost(lens.lookupInternalName(nestHost));
}
+
+ @Override
+ public NestHostClassAttribute self() {
+ return this;
+ }
+
+ @Override
+ public StructuralMapping<NestHostClassAttribute> getStructuralMapping() {
+ return NestHostClassAttribute::specify;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
index f9d1a35..0d7c19d 100644
--- a/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
+++ b/src/main/java/com/android/tools/r8/graph/NestMemberClassAttribute.java
@@ -5,14 +5,21 @@
package com.android.tools.r8.graph;
import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.utils.structural.StructuralItem;
+import com.android.tools.r8.utils.structural.StructuralMapping;
+import com.android.tools.r8.utils.structural.StructuralSpecification;
import java.util.Collections;
import java.util.List;
import org.objectweb.asm.ClassWriter;
-public class NestMemberClassAttribute {
+public class NestMemberClassAttribute implements StructuralItem<NestMemberClassAttribute> {
private final DexType nestMember;
+ private static void specify(StructuralSpecification<NestMemberClassAttribute, ?> spec) {
+ spec.withItem(a -> a.nestMember);
+ }
+
public NestMemberClassAttribute(DexType nestMember) {
this.nestMember = nestMember;
}
@@ -29,4 +36,14 @@
assert nestMember != null;
writer.visitNestMember(lens.lookupInternalName(nestMember));
}
+
+ @Override
+ public NestMemberClassAttribute self() {
+ return this;
+ }
+
+ @Override
+ public StructuralMapping<NestMemberClassAttribute> getStructuralMapping() {
+ return NestMemberClassAttribute::specify;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
index edb5e46..3356777 100644
--- a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
@@ -567,18 +567,14 @@
public LookupTarget lookupVirtualDispatchTarget(
LambdaDescriptor lambdaInstance, AppInfoWithClassHierarchy appInfo) {
if (lambdaInstance.getMainMethod().match(resolvedMethod)) {
- DexMethod method = lambdaInstance.implHandle.asMethod();
- DexClass holder = appInfo.definitionForHolder(method);
- if (holder == null) {
- assert false;
- return null;
- }
- DexEncodedMethod definition = holder.lookupMethod(method);
- if (definition == null) {
+ DexMethod methodReference = lambdaInstance.implHandle.asMethod();
+ DexClass holder = appInfo.definitionForHolder(methodReference);
+ DexClassAndMethod method = methodReference.lookupMemberOnClass(holder);
+ if (method == null) {
// The targeted method might not exist, eg, Throwable.addSuppressed in an old library.
return null;
}
- return new LookupLambdaTarget(lambdaInstance, DexClassAndMethod.create(holder, definition));
+ return new LookupLambdaTarget(lambdaInstance, method);
}
return lookupMaximallySpecificDispatchTarget(lambdaInstance, appInfo);
}
diff --git a/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java b/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
index a10db7147..89d0bd7 100644
--- a/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
+++ b/src/main/java/com/android/tools/r8/graph/TreeFixerBase.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.ArrayList;
import java.util.Collection;
import java.util.IdentityHashMap;
@@ -15,7 +16,7 @@
private final AppView<?> appView;
private final DexItemFactory dexItemFactory;
- private Map<DexType, DexProgramClass> newProgramClasses = null;
+ private final Map<DexType, DexProgramClass> programClassCache = new IdentityHashMap<>();
private final Map<DexType, DexProgramClass> synthesizedFromClasses = new IdentityHashMap<>();
private final Map<DexProto, DexProto> protoFixupCache = new IdentityHashMap<>();
@@ -46,6 +47,34 @@
return to;
}
+ /** Rewrite missing references */
+ public void recordFailedResolutionChanges() {
+ // In order for optimizations to correctly rewrite field and method references that do not
+ // resolve, we create a mapping from each failed resolution target to its reference reference.
+ if (!appView.appInfo().hasLiveness()) {
+ return;
+ }
+ AppInfoWithLiveness appInfoWithLiveness = appView.appInfo().withLiveness();
+ appInfoWithLiveness
+ .getFailedFieldResolutionTargets()
+ .forEach(
+ field -> {
+ DexField fixedUpField = fixupFieldReference(field);
+ if (field != fixedUpField) {
+ recordFieldChange(field, fixedUpField);
+ }
+ });
+ appInfoWithLiveness
+ .getFailedMethodResolutionTargets()
+ .forEach(
+ method -> {
+ DexMethod fixedUpMethod = fixupMethodReference(method);
+ if (method != fixedUpMethod) {
+ recordMethodChange(method, fixedUpMethod);
+ }
+ });
+ }
+
/** Callback to allow custom handling when an encoded method changes. */
public DexEncodedMethod recordMethodChange(DexEncodedMethod from, DexEncodedMethod to) {
recordMethodChange(from.method, to.method);
@@ -53,13 +82,13 @@
}
/** Fixup a collection of classes. */
- public Collection<DexProgramClass> fixupClasses(Collection<DexProgramClass> classes) {
- assert newProgramClasses == null;
- newProgramClasses = new IdentityHashMap<>();
+ public List<DexProgramClass> fixupClasses(Collection<DexProgramClass> classes) {
+ List<DexProgramClass> newProgramClasses = new ArrayList<>();
for (DexProgramClass clazz : classes) {
- newProgramClasses.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz));
+ newProgramClasses.add(
+ programClassCache.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz)));
}
- return newProgramClasses.values();
+ return newProgramClasses;
}
// Should remain private as the correctness of the fixup requires the lazy 'newProgramClasses'.
@@ -70,7 +99,7 @@
clazz.getOriginKind(),
clazz.getOrigin(),
clazz.getAccessFlags(),
- fixupType(clazz.superType),
+ clazz.superType == null ? null : fixupType(clazz.superType),
fixupTypeList(clazz.interfaces),
clazz.getSourceFile(),
fixupNestHost(clazz.getNestHostClassAttribute()),
@@ -250,7 +279,6 @@
// Should remain private as its correctness relies on the setup of 'newProgramClasses'.
private Collection<DexProgramClass> fixupSynthesizedFrom(
Collection<DexProgramClass> synthesizedFrom) {
- assert newProgramClasses != null;
if (synthesizedFrom.isEmpty()) {
return synthesizedFrom;
}
@@ -261,7 +289,7 @@
// is no longer in the application?
Map<DexType, DexProgramClass> classes =
appView.appInfo().definitionForWithoutExistenceAssert(clazz.getType()) != null
- ? newProgramClasses
+ ? programClassCache
: synthesizedFromClasses;
DexProgramClass newClass =
classes.computeIfAbsent(clazz.getType(), ignore -> fixupClass(clazz));
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
index 0a6a9b9..11001de 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -172,7 +172,7 @@
return dexItemFactory.createFreshMethodName(
method.getDefinition().method.name.toSourceString(),
method.getHolderType(),
- method.getDefinition().proto(),
+ method.getDefinition().getProto(),
group.getTarget().getType(),
classMethodsBuilder::isFresh);
}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMethodsBuilder.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMethodsBuilder.java
index 13c01eb..b87c6ad 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMethodsBuilder.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMethodsBuilder.java
@@ -35,9 +35,9 @@
public void setClassMethods(DexProgramClass clazz) {
assert virtualMethods.stream().allMatch(method -> method.getHolderType() == clazz.type);
- assert virtualMethods.stream().allMatch(method -> method.belongsToVirtualPool());
+ assert virtualMethods.stream().allMatch(DexEncodedMethod::belongsToVirtualPool);
assert directMethods.stream().allMatch(method -> method.getHolderType() == clazz.type);
- assert directMethods.stream().allMatch(method -> method.belongsToDirectPool());
+ assert directMethods.stream().allMatch(DexEncodedMethod::belongsToDirectPool);
clazz.setVirtualMethods(virtualMethods);
clazz.setDirectMethods(directMethods);
}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
index b4e9887..13673fa 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
@@ -45,7 +45,7 @@
// Constructors should not be empty and all constructors should have the same prototype.
assert !constructors.isEmpty();
- assert constructors.stream().map(DexEncodedMethod::proto).distinct().count() == 1;
+ assert constructors.stream().map(DexEncodedMethod::getProto).distinct().count() == 1;
this.dexItemFactory = appView.dexItemFactory();
}
@@ -113,7 +113,7 @@
dexItemFactory.createFreshMethodName(
TEMPORARY_INSTANCE_INITIALIZER_PREFIX,
constructor.getHolderType(),
- constructor.proto(),
+ constructor.getProto(),
group.getTarget().getType(),
classMethodsBuilder::isFresh);
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
index 015b182..2b5e70f 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
@@ -62,7 +62,7 @@
public void recordFieldAccesses(
IRCode code, OptimizationFeedback feedback, MethodProcessor methodProcessor) {
- if (!methodProcessor.isPrimary()) {
+ if (!methodProcessor.isPrimaryMethodProcessor()) {
return;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 281215f..fc01602 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -12,9 +12,6 @@
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexClassAndMethod;
import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.DexValue;
import com.android.tools.r8.graph.DexValue.DexValueNull;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
@@ -26,6 +23,7 @@
import com.android.tools.r8.ir.analysis.value.NullOrAbstractValue;
import com.android.tools.r8.ir.analysis.value.ObjectState;
import com.android.tools.r8.ir.analysis.value.SingleFieldValue;
+import com.android.tools.r8.ir.analysis.value.UnknownValue;
import com.android.tools.r8.ir.code.ArrayPut;
import com.android.tools.r8.ir.code.FieldInstruction;
import com.android.tools.r8.ir.code.IRCode;
@@ -40,10 +38,13 @@
import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoCollection;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.Timing;
+import java.util.IdentityHashMap;
+import java.util.Map;
public class StaticFieldValueAnalysis extends FieldValueAnalysis {
private final StaticFieldValues.Builder builder;
+ private final Map<Value, AbstractValue> computedValues = new IdentityHashMap<>();
private StaticFieldValueAnalysis(
AppView<AppInfoWithLiveness> appView, IRCode code, OptimizationFeedback feedback) {
@@ -63,7 +64,7 @@
timing.begin("Analyze class initializer");
StaticFieldValues result =
new StaticFieldValueAnalysis(appView.withLiveness(), code, feedback)
- .analyze(classInitializerDefaultsResult, code.context().getHolderType());
+ .analyze(classInitializerDefaultsResult);
timing.end();
return result;
}
@@ -78,8 +79,7 @@
return this;
}
- StaticFieldValues analyze(
- ClassInitializerDefaultsResult classInitializerDefaultsResult, DexType holderType) {
+ StaticFieldValues analyze(ClassInitializerDefaultsResult classInitializerDefaultsResult) {
computeFieldOptimizationInfo(classInitializerDefaultsResult);
return builder.build();
}
@@ -218,16 +218,41 @@
return null;
}
assert !value.hasAliasedValue();
- if (isEnumValuesArray(value)) {
+ if (value.isPhi()) {
+ return null;
+ }
+ if (value.definition.isNewArrayEmpty()) {
return computeSingleEnumFieldValueForValuesArray(value);
}
- return computeSingleEnumFieldValueForInstance(value);
+ if (value.definition.isNewInstance()) {
+ return computeSingleEnumFieldValueForInstance(value);
+ }
+ return null;
}
private SingleFieldValue computeSingleEnumFieldValueForValuesArray(Value value) {
- if (!value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty)) {
+ if (!value.definition.isNewArrayEmpty()) {
return null;
}
+ AbstractValue valuesValue = computedValues.get(value);
+ if (valuesValue != null) {
+ // This implicitely answers null if the value could not get computed.
+ if (valuesValue.isSingleFieldValue()) {
+ SingleFieldValue fieldValue = valuesValue.asSingleFieldValue();
+ if (fieldValue.getState().isEnumValuesObjectState()) {
+ return fieldValue;
+ }
+ }
+ return null;
+ }
+ SingleFieldValue singleFieldValue = internalComputeSingleEnumFieldValueForValuesArray(value);
+ computedValues.put(
+ value, singleFieldValue == null ? UnknownValue.getInstance() : singleFieldValue);
+ return singleFieldValue;
+ }
+
+ private SingleFieldValue internalComputeSingleEnumFieldValueForValuesArray(Value value) {
+ assert value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty);
NewArrayEmpty newArrayEmpty = value.definition.asNewArrayEmpty();
if (newArrayEmpty.type.toBaseType(appView.dexItemFactory()) != context.getHolder().type) {
@@ -267,7 +292,9 @@
// We need the state of all fields for the analysis to be valuable.
return null;
}
- assert verifyValuesArrayIndexMatchesOrdinal(index, objectState);
+ if (!valuesArrayIndexMatchesOrdinal(index, objectState)) {
+ return null;
+ }
if (valuesState[index] != null) {
return null;
}
@@ -326,24 +353,25 @@
return ObjectState.empty();
}
- private boolean verifyValuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
+ private boolean valuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
DexEncodedField ordinalField =
appView
.appInfo()
.resolveField(appView.dexItemFactory().enumMembers.ordinalField, context)
.getResolvedField();
- assert ordinalField != null;
+ if (ordinalField == null) {
+ return false;
+ }
AbstractValue ordinalState = objectState.getAbstractFieldValue(ordinalField);
- assert ordinalState != null;
- assert ordinalState.isSingleNumberValue();
- assert ordinalState.asSingleNumberValue().getIntValue() == ordinal;
- return true;
+ if (ordinalState == null || !ordinalState.isSingleNumberValue()) {
+ return false;
+ }
+ int intValue = ordinalState.asSingleNumberValue().getIntValue();
+ return intValue == ordinal;
}
private SingleFieldValue computeSingleEnumFieldValueForInstance(Value value) {
- if (!value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
- return null;
- }
+ assert value.isDefinedByInstructionSatisfying(Instruction::isNewInstance);
NewInstance newInstance = value.definition.asNewInstance();
// Some enums have direct subclasses, and the subclass is instantiated here.
@@ -459,30 +487,7 @@
}
private boolean isEnumValuesArray(Value value) {
- assert context.getHolder().isEnum();
- DexItemFactory dexItemFactory = appView.dexItemFactory();
- DexField valuesField =
- dexItemFactory.createField(
- context.getHolderType(),
- context.getHolderType().toArrayType(1, dexItemFactory),
- dexItemFactory.enumValuesFieldName);
-
- Value root = value.getAliasedValue();
- if (root.isPhi()) {
- return false;
- }
-
- Instruction definition = root.definition;
- if (definition.isNewArrayEmpty()) {
- for (Instruction user : root.aliasedUsers()) {
- if (user.isStaticPut() && user.asStaticPut().getField() == valuesField) {
- return true;
- }
- }
- } else if (definition.isStaticGet()) {
- return definition.asStaticGet().getField() == valuesField;
- }
-
- return false;
+ SingleFieldValue singleFieldValue = computeSingleEnumFieldValueForValuesArray(value);
+ return singleFieldValue != null && singleFieldValue.getState().isEnumValuesObjectState();
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
index b2dcdcd..65e1ea3 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValues.java
@@ -37,17 +37,10 @@
// All the abstract values stored here may match a pinned field, using them requires therefore
// to check the field is not pinned or prove it is no longer pinned.
public static class EnumStaticFieldValues extends StaticFieldValues {
- private final ImmutableMap<DexField, AbstractValue> enumAbstractValues;
- private final DexField valuesField;
- private final AbstractValue valuesAbstractValue;
+ private final ImmutableMap<DexField, ObjectState> enumAbstractValues;
- public EnumStaticFieldValues(
- ImmutableMap<DexField, AbstractValue> enumAbstractValues,
- DexField valuesField,
- AbstractValue valuesAbstractValue) {
+ public EnumStaticFieldValues(ImmutableMap<DexField, ObjectState> enumAbstractValues) {
this.enumAbstractValues = enumAbstractValues;
- this.valuesField = valuesField;
- this.valuesAbstractValue = valuesAbstractValue;
}
static StaticFieldValues.Builder builder() {
@@ -55,33 +48,38 @@
}
public static class Builder extends StaticFieldValues.Builder {
- private final ImmutableMap.Builder<DexField, AbstractValue> enumAbstractValuesBuilder =
+ private final ImmutableMap.Builder<DexField, ObjectState> enumObjectStateBuilder =
ImmutableMap.builder();
- private DexField valuesFields;
- private AbstractValue valuesAbstractValue;
+ private AbstractValue valuesCandidateAbstractValue;
Builder() {}
@Override
public void recordStaticField(
DexEncodedField staticField, AbstractValue value, DexItemFactory factory) {
- // TODO(b/166532388): Stop relying on the values name.
- if (staticField.getName() == factory.enumValuesFieldName) {
- valuesFields = staticField.field;
- valuesAbstractValue = value;
- } else if (staticField.isEnum()) {
- enumAbstractValuesBuilder.put(staticField.field, value);
+ if (factory.enumMembers.isValuesFieldCandidate(staticField, staticField.getHolderType())) {
+ if (value.isSingleFieldValue()
+ && value.asSingleFieldValue().getState().isEnumValuesObjectState()) {
+ assert valuesCandidateAbstractValue == null
+ || valuesCandidateAbstractValue.equals(value);
+ valuesCandidateAbstractValue = value;
+ enumObjectStateBuilder.put(staticField.field, value.asSingleFieldValue().getState());
+ }
+ } else if (factory.enumMembers.isEnumField(staticField, staticField.getHolderType())) {
+ if (value.isSingleFieldValue() && !value.asSingleFieldValue().getState().isEmpty()) {
+ enumObjectStateBuilder.put(staticField.field, value.asSingleFieldValue().getState());
+ }
}
}
@Override
public StaticFieldValues build() {
- ImmutableMap<DexField, AbstractValue> enumAbstractValues =
- enumAbstractValuesBuilder.build();
- if (valuesAbstractValue == null && enumAbstractValues.isEmpty()) {
+ ImmutableMap<DexField, ObjectState> enumAbstractValues = enumObjectStateBuilder.build();
+ if (enumAbstractValues.isEmpty()) {
return EmptyStaticValues.getInstance();
}
- return new EnumStaticFieldValues(enumAbstractValues, valuesFields, valuesAbstractValue);
+ assert enumAbstractValues.values().stream().noneMatch(ObjectState::isEmpty);
+ return new EnumStaticFieldValues(enumAbstractValues);
}
}
@@ -96,20 +94,7 @@
}
public ObjectState getObjectStateForPossiblyPinnedField(DexField field) {
- AbstractValue fieldValue = enumAbstractValues.get(field);
- if (fieldValue == null || fieldValue.isZero()) {
- return null;
- }
- if (fieldValue.isSingleFieldValue()) {
- return fieldValue.asSingleFieldValue().getState();
- }
- assert fieldValue.isUnknown();
- return ObjectState.empty();
- }
-
- public AbstractValue getValuesAbstractValueForPossiblyPinnedField(DexField field) {
- assert valuesField == field || valuesAbstractValue == null;
- return valuesAbstractValue;
+ return enumAbstractValues.get(field);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeElement.java
index eeeea70..144f465 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeElement.java
@@ -8,19 +8,21 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection.Builder;
+import com.android.tools.r8.utils.BooleanBox;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.OptionalBool;
+import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.SetUtils;
-import com.google.common.collect.ImmutableSet;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
+import java.util.Comparator;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
-import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
@@ -28,14 +30,14 @@
// Least upper bound of interfaces that this class type is implementing.
// Lazily computed on demand via DexItemFactory, where the canonicalized set will be maintained.
- private Set<DexType> lazyInterfaces;
+ private InterfaceCollection lazyInterfaces;
private AppView<? extends AppInfoWithClassHierarchy> appView;
// On-demand link between other nullability-variants.
private final NullabilityVariants<ClassTypeElement> variants;
private final DexType type;
public static ClassTypeElement create(
- DexType classType, Nullability nullability, Set<DexType> interfaces) {
+ DexType classType, Nullability nullability, InterfaceCollection interfaces) {
assert interfaces != null;
return NullabilityVariants.create(
nullability,
@@ -55,7 +57,7 @@
private ClassTypeElement(
DexType classType,
Nullability nullability,
- Set<DexType> interfaces,
+ InterfaceCollection interfaces,
NullabilityVariants<ClassTypeElement> variants,
AppView<? extends AppInfoWithClassHierarchy> appView) {
super(nullability);
@@ -71,7 +73,7 @@
return type;
}
- public Set<DexType> getInterfaces() {
+ public InterfaceCollection getInterfaces() {
if (lazyInterfaces == null) {
assert appView != null;
lazyInterfaces =
@@ -105,8 +107,8 @@
@Override
public boolean isBasedOnMissingClass(AppView<? extends AppInfoWithClassHierarchy> appView) {
return appView.appInfo().isMissingOrHasMissingSuperType(getClassType())
- || getInterfaces().stream()
- .anyMatch(type -> appView.appInfo().isMissingOrHasMissingSuperType(type));
+ || getInterfaces()
+ .anyMatch((iface, isKnown) -> appView.appInfo().isMissingOrHasMissingSuperType(iface));
}
@Override
@@ -131,13 +133,17 @@
builder.append(" ");
builder.append(type);
builder.append(" {");
- Set<DexType> interfaces = getInterfaces();
- if (interfaces != null) {
- List<DexType> sortedInterfaces = new ArrayList<>(interfaces);
- sortedInterfaces.sort(DexType::compareTo);
- builder.append(
- sortedInterfaces.stream().map(DexType::toString).collect(Collectors.joining(", ")));
- }
+ InterfaceCollection interfaces = getInterfaces();
+ List<Pair<DexType, Boolean>> sortedInterfaces = interfaces.getInterfaceList();
+ sortedInterfaces.sort(Comparator.comparing(Pair::getFirst));
+ builder.append(
+ sortedInterfaces.stream()
+ .map(
+ pair ->
+ pair.getSecond()
+ ? pair.getFirst().toString()
+ : ("maybe(" + pair.getFirst() + ")"))
+ .collect(Collectors.joining(", ")));
builder.append("}");
return builder.toString();
}
@@ -165,36 +171,42 @@
// For most types there will not have been a change thus we iterate without allocating a new
// set for holding modified interfaces.
- boolean hasChangedInterfaces = false;
- DexClass interfaceToClassChange = null;
- for (DexType iface : getInterfaces()) {
- DexType substitutedType = mapping.apply(iface);
- if (iface != substitutedType) {
- hasChangedInterfaces = true;
- DexClass mappedClass = appView.definitionFor(substitutedType);
- if (!mappedClass.isInterface()) {
- if (interfaceToClassChange != null && mappedClass != interfaceToClassChange) {
- throw new CompilationError(
- "More than one interface has changed to a class: "
- + interfaceToClassChange
- + " and "
- + mappedClass);
- }
- interfaceToClassChange = mappedClass;
- }
- }
- }
- if (hasChangedInterfaces) {
- if (interfaceToClassChange != null) {
- assert !interfaceToClassChange.isInterface();
+ BooleanBox hasChangedInterfaces = new BooleanBox();
+ Box<DexClass> interfaceToClassChange = new Box<>();
+ getInterfaces()
+ .forEach(
+ (iface, isKnown) -> {
+ DexType substitutedType = mapping.apply(iface);
+ if (iface != substitutedType) {
+ hasChangedInterfaces.set();
+ DexClass mappedClass = appView.definitionFor(substitutedType);
+ if (!mappedClass.isInterface()) {
+ if (interfaceToClassChange.isSet()
+ && mappedClass != interfaceToClassChange.get()) {
+ throw new CompilationError(
+ "More than one interface has changed to a class: "
+ + interfaceToClassChange.get()
+ + " and "
+ + mappedClass);
+ }
+ interfaceToClassChange.set(mappedClass);
+ }
+ }
+ });
+ if (hasChangedInterfaces.get()) {
+ if (interfaceToClassChange.isSet()) {
+ assert !interfaceToClassChange.get().isInterface();
assert type == appView.dexItemFactory().objectType;
- return create(interfaceToClassChange.type, nullability, appView);
+ return create(interfaceToClassChange.get().type, nullability, appView);
} else {
- Set<DexType> newInterfaces = new HashSet<>();
- for (DexType iface : lazyInterfaces) {
- newInterfaces.add(mapping.apply(iface));
- }
- return create(mappedType, nullability, newInterfaces);
+ Builder builder = InterfaceCollection.builder();
+ lazyInterfaces.forEach(
+ (iface, isKnown) -> {
+ DexType rewritten = mapping.apply(iface);
+ assert iface == rewritten || isKnown : "Rewritten implies program types thus known.";
+ builder.addInterface(rewritten, isKnown);
+ });
+ return create(mappedType, nullability, builder.build());
}
}
return this;
@@ -210,15 +222,15 @@
? getClassType()
: appView.dexItemFactory().objectType,
nullability,
- Collections.emptySet());
+ InterfaceCollection.empty());
}
DexType lubType =
computeLeastUpperBoundOfClasses(
appView.appInfo().withClassHierarchy(), getClassType(), other.getClassType());
- Set<DexType> c1lubItfs = getInterfaces();
- Set<DexType> c2lubItfs = other.getInterfaces();
- Set<DexType> lubItfs = null;
- if (c1lubItfs.size() == c2lubItfs.size() && c1lubItfs.containsAll(c2lubItfs)) {
+ InterfaceCollection c1lubItfs = getInterfaces();
+ InterfaceCollection c2lubItfs = other.getInterfaces();
+ InterfaceCollection lubItfs = null;
+ if (c1lubItfs.equals(c2lubItfs)) {
lubItfs = c1lubItfs;
}
if (lubItfs == null) {
@@ -228,9 +240,85 @@
return ClassTypeElement.create(lubType, nullability, lubItfs);
}
- private enum InterfaceMarker {
- LEFT,
- RIGHT
+ /**
+ * Internal marker for finding the LUB between sets of interfaces.
+ *
+ * <p>The marker is used both as the identification of which side the traversal is on and if that
+ * item is known to always be present. That use denotes a immutable use fo the marker and reuses
+ * the static constants defined below. When traversing the interface super chains each point is
+ * mapped to a mutable marking that keeps track of what paths have reached it. The mutable use is
+ * allocated with 'createEmpty' and updated with 'merge'.
+ */
+ private static class InterfaceMarker {
+
+ // Each side is tracked with a three-valued marking.
+ // Note that the value FALSE is not part of the possible three values, only:
+ // FALSE: not marked / not present.
+ // TRUE: marked and known to be present.
+ // UNKNOWN: marked and unknown if actually present.
+ private OptionalBool left;
+ private OptionalBool right;
+
+ static final InterfaceMarker LEFT_KNOWN =
+ new InterfaceMarker(OptionalBool.TRUE, OptionalBool.FALSE);
+ static final InterfaceMarker LEFT_UNKNOWN =
+ new InterfaceMarker(OptionalBool.UNKNOWN, OptionalBool.FALSE);
+ static final InterfaceMarker RIGHT_KNOWN =
+ new InterfaceMarker(OptionalBool.FALSE, OptionalBool.TRUE);
+ static final InterfaceMarker RIGHT_UNKNOWN =
+ new InterfaceMarker(OptionalBool.FALSE, OptionalBool.UNKNOWN);
+
+ static InterfaceMarker forLeft(boolean isKnown) {
+ return isKnown ? LEFT_KNOWN : LEFT_UNKNOWN;
+ }
+
+ static InterfaceMarker forRight(boolean isKnown) {
+ return isKnown ? RIGHT_KNOWN : RIGHT_UNKNOWN;
+ }
+
+ static InterfaceMarker createUnmarked() {
+ return new InterfaceMarker(OptionalBool.FALSE, OptionalBool.FALSE);
+ }
+
+ public InterfaceMarker(OptionalBool left, OptionalBool right) {
+ this.left = left;
+ this.right = right;
+ assert !isMarkedOnBothSides();
+ }
+
+ boolean isMarked() {
+ return left.isPossiblyTrue() || right.isPossiblyTrue();
+ }
+
+ boolean isMarkedOnBothSides() {
+ return left.isPossiblyTrue() && right.isPossiblyTrue();
+ }
+
+ static OptionalBool knownIfAnyIsKnown(OptionalBool v1, OptionalBool v2) {
+ assert v1.isPossiblyTrue() || v2.isPossiblyTrue();
+ return v1.isTrue() || v2.isTrue() ? OptionalBool.TRUE : OptionalBool.UNKNOWN;
+ }
+
+ boolean knownIfBothAreKnown() {
+ assert isMarkedOnBothSides();
+ return left.isTrue() && right.isTrue();
+ }
+
+ boolean merge(InterfaceMarker marker) {
+ assert marker.isMarked();
+ assert !marker.isMarkedOnBothSides();
+ if (marker.left.isPossiblyTrue()) {
+ OptionalBool oldLeft = left;
+ left = knownIfAnyIsKnown(left, marker.left);
+ // Only continue if the other side is absent and this side changed.
+ return right.isFalse() && left != oldLeft;
+ } else {
+ OptionalBool oldRight = right;
+ right = knownIfAnyIsKnown(right, marker.right);
+ // Only continue if the other side is absent and this side changed.
+ return left.isFalse() && right != oldRight;
+ }
+ }
}
private static class InterfaceWithMarker {
@@ -287,12 +375,15 @@
return objectType;
}
- public static Set<DexType> computeLeastUpperBoundOfInterfaces(
- AppView<? extends AppInfoWithClassHierarchy> appView, Set<DexType> s1, Set<DexType> s2) {
+ public static InterfaceCollection computeLeastUpperBoundOfInterfaces(
+ AppView<? extends AppInfoWithClassHierarchy> appView,
+ InterfaceCollection s1,
+ InterfaceCollection s2) {
if (s1.isEmpty() || s2.isEmpty()) {
- return Collections.emptySet();
+ return InterfaceCollection.empty();
}
- Set<DexType> cached = appView.dexItemFactory().leastUpperBoundOfInterfacesTable.get(s1, s2);
+ InterfaceCollection cached =
+ appView.dexItemFactory().leastUpperBoundOfInterfacesTable.get(s1, s2);
if (cached != null) {
return cached;
}
@@ -300,58 +391,46 @@
if (cached != null) {
return cached;
}
- Map<DexType, Set<InterfaceMarker>> seen = new IdentityHashMap<>();
+ Map<DexType, InterfaceMarker> seen = new IdentityHashMap<>();
Queue<InterfaceWithMarker> worklist = new ArrayDeque<>();
- for (DexType itf1 : s1) {
- worklist.add(new InterfaceWithMarker(itf1, InterfaceMarker.LEFT));
- }
- for (DexType itf2 : s2) {
- worklist.add(new InterfaceWithMarker(itf2, InterfaceMarker.RIGHT));
- }
+ s1.forEach(
+ (itf1, isKnown) ->
+ worklist.add(new InterfaceWithMarker(itf1, InterfaceMarker.forLeft(isKnown))));
+ s2.forEach(
+ (itf2, isKnown) ->
+ worklist.add(new InterfaceWithMarker(itf2, InterfaceMarker.forRight(isKnown))));
+
while (!worklist.isEmpty()) {
InterfaceWithMarker item = worklist.poll();
DexType itf = item.itf;
InterfaceMarker marker = item.marker;
- Set<InterfaceMarker> markers = seen.computeIfAbsent(itf, k -> new HashSet<>());
- // If this interface is a lower one in this set, skip.
- if (markers.contains(marker)) {
- continue;
- }
- // If this interface is already visited by the other set, add marker for this set and skip.
- if (markers.size() == 1) {
- markers.add(marker);
- continue;
- }
- // Otherwise, this type is freshly visited.
- markers.add(marker);
- // Put super interfaces into the worklist.
- DexClass itfClass = appView.definitionFor(itf);
- if (itfClass != null) {
- for (DexType superItf : itfClass.interfaces.values) {
- markers = seen.computeIfAbsent(superItf, k -> new HashSet<>());
- if (!markers.contains(marker)) {
+ InterfaceMarker marking = seen.computeIfAbsent(itf, k -> InterfaceMarker.createUnmarked());
+ if (marking.merge(marker)) {
+ // Put super interfaces into the worklist.
+ DexClass itfClass = appView.definitionFor(itf);
+ if (itfClass != null) {
+ for (DexType superItf : itfClass.interfaces.values) {
worklist.add(new InterfaceWithMarker(superItf, marker));
}
}
}
}
- ImmutableSet.Builder<DexType> commonBuilder = ImmutableSet.builder();
- for (Map.Entry<DexType, Set<InterfaceMarker>> entry : seen.entrySet()) {
- // Keep commonly visited interfaces only
- if (entry.getValue().size() < 2) {
- continue;
- }
- commonBuilder.add(entry.getKey());
- }
- Set<DexType> commonlyVisited = commonBuilder.build();
+ List<Pair<DexType, Boolean>> commonlyVisited = new ArrayList<>(seen.size());
+ seen.forEach(
+ (itf, marking) -> {
+ // Keep commonly visited interfaces only
+ if (marking.isMarkedOnBothSides()) {
+ commonlyVisited.add(new Pair<>(itf, marking.knownIfBothAreKnown()));
+ }
+ });
- ImmutableSet.Builder<DexType> lubBuilder = ImmutableSet.builder();
- for (DexType itf : commonlyVisited) {
+ Builder lubBuilder = InterfaceCollection.builder();
+ for (Pair<DexType, Boolean> entry : commonlyVisited) {
// If there is a strict sub interface of this interface, it is not the least element.
boolean notTheLeast = false;
- for (DexType other : commonlyVisited) {
- if (appView.appInfo().isStrictSubtypeOf(other, itf)) {
+ for (Pair<DexType, Boolean> other : commonlyVisited) {
+ if (appView.appInfo().isStrictSubtypeOf(other.getFirst(), entry.getFirst())) {
notTheLeast = true;
break;
}
@@ -359,11 +438,11 @@
if (notTheLeast) {
continue;
}
- lubBuilder.add(itf);
+ lubBuilder.addInterface(entry.getFirst(), entry.getSecond());
}
- Set<DexType> lub = lubBuilder.build();
+ InterfaceCollection lub = lubBuilder.build();
// Cache the computation result only if the given two sets of interfaces are different.
- if (s1.size() != s2.size() || !s1.containsAll(s2)) {
+ if (!s1.equals(s2)) {
synchronized (appView.dexItemFactory().leastUpperBoundOfInterfacesTable) {
appView.dexItemFactory().leastUpperBoundOfInterfacesTable.put(s1, s2, lub);
}
@@ -386,14 +465,6 @@
if (!type.equals(other.type)) {
return false;
}
- Set<DexType> thisInterfaces = getInterfaces();
- Set<DexType> otherInterfaces = other.getInterfaces();
- if (thisInterfaces == otherInterfaces) {
- return true;
- }
- if (thisInterfaces.size() != otherInterfaces.size()) {
- return false;
- }
- return thisInterfaces.containsAll(otherInterfaces);
+ return getInterfaces().equals(other.getInterfaces());
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/InterfaceCollection.java b/src/main/java/com/android/tools/r8/ir/analysis/type/InterfaceCollection.java
new file mode 100644
index 0000000..7b80c82
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/InterfaceCollection.java
@@ -0,0 +1,163 @@
+// 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.ir.analysis.type;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.OptionalBool;
+import com.android.tools.r8.utils.Pair;
+import it.unimi.dsi.fastutil.objects.Reference2BooleanMap;
+import it.unimi.dsi.fastutil.objects.Reference2BooleanMap.Entry;
+import it.unimi.dsi.fastutil.objects.Reference2BooleanMaps;
+import it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+
+public class InterfaceCollection {
+
+ public static boolean isKnownToImplement(
+ DexType iface, DexType implementor, InternalOptions options) {
+ if (options.canHaveZipFileWithMissingCloseableBug()
+ && implementor == options.dexItemFactory().zipFileType
+ && iface == options.dexItemFactory().closeableType) {
+ return false;
+ }
+ return true;
+ }
+
+ public static class Builder {
+ private Reference2BooleanMap<DexType> interfaces = new Reference2BooleanOpenHashMap<>();
+
+ private Builder() {}
+
+ public Builder addInterface(DexType iface, DexClass implementor, InternalOptions options) {
+ return addInterface(
+ iface,
+ !implementor.isLibraryClass()
+ || isKnownToImplement(iface, implementor.getType(), options));
+ }
+
+ public Builder addInterface(DexType iface, DexType implementor, InternalOptions options) {
+ return addInterface(iface, isKnownToImplement(iface, implementor, options));
+ }
+
+ public Builder addInterface(DexType type, boolean isKnown) {
+ interfaces.compute(
+ type,
+ (existingType, existingIsKnown) ->
+ // If the entry is new 'existingIsKnown == null', so we join with (null or true).
+ (existingIsKnown == null || existingIsKnown) && isKnown);
+ return this;
+ }
+
+ public InterfaceCollection build() {
+ if (interfaces.isEmpty()) {
+ return InterfaceCollection.empty();
+ }
+ return new InterfaceCollection(interfaces);
+ }
+ }
+
+ private static final InterfaceCollection EMPTY =
+ new InterfaceCollection(Reference2BooleanMaps.emptyMap());
+
+ public static InterfaceCollection empty() {
+ return EMPTY;
+ }
+
+ public static InterfaceCollection singleton(DexType type) {
+ return new InterfaceCollection(Reference2BooleanMaps.singleton(type, true));
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /**
+ * Set of interfaces mapping to an optional presence.
+ *
+ * <ul>
+ * <li>An unmapped type is known to not be present.
+ * <li>A type mapped to true is known to always be present.
+ * <li>A type mapped to false is not always known to be present.
+ */
+ private final Reference2BooleanMap<DexType> interfaces;
+
+ private InterfaceCollection(Reference2BooleanMap<DexType> interfaces) {
+ assert interfaces != null;
+ this.interfaces = interfaces;
+ }
+
+ public boolean isEmpty() {
+ return interfaces.isEmpty();
+ }
+
+ public int size() {
+ return interfaces.size();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof InterfaceCollection)) {
+ return false;
+ }
+ InterfaceCollection that = (InterfaceCollection) o;
+ return interfaces.equals(that.interfaces);
+ }
+
+ @Override
+ public int hashCode() {
+ return interfaces.hashCode();
+ }
+
+ public void forEach(BiConsumer<DexType, Boolean> fn) {
+ interfaces.forEach(fn::accept);
+ }
+
+ public boolean anyMatch(BiPredicate<DexType, Boolean> fn) {
+ for (Entry<DexType> entry : interfaces.reference2BooleanEntrySet()) {
+ if (fn.test(entry.getKey(), entry.getBooleanValue())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public List<Pair<DexType, Boolean>> getInterfaceList() {
+ List<Pair<DexType, Boolean>> list = new ArrayList<>(interfaces.size());
+ interfaces.forEach((iface, isKnown) -> list.add(new Pair<>(iface, isKnown)));
+ return list;
+ }
+
+ public boolean hasSingleKnownInterface() {
+ DexType singleKnownInterface = getSingleKnownInterface();
+ return singleKnownInterface != null;
+ }
+
+ public DexType getSingleKnownInterface() {
+ if (interfaces.size() != 1) {
+ return null;
+ }
+ DexType type = interfaces.keySet().iterator().next();
+ return interfaces.getBoolean(type) ? type : null;
+ }
+
+ public OptionalBool contains(DexType type) {
+ Boolean value = interfaces.get(type);
+ if (value == null) {
+ return OptionalBool.FALSE;
+ }
+ return value ? OptionalBool.TRUE : OptionalBool.unknown();
+ }
+
+ public boolean containsKnownInterface(DexType type) {
+ return contains(type).isTrue();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
index 94b9489..d06fd44 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
@@ -18,7 +18,6 @@
import java.util.Comparator;
import java.util.Deque;
import java.util.List;
-import java.util.Set;
public class TypeAnalysis {
@@ -181,9 +180,9 @@
ClassTypeElement classType = receiverUpperBoundType.asClassType();
DexType refinedType = classType.getClassType();
if (refinedType == appView.dexItemFactory().objectType) {
- Set<DexType> interfaces = classType.getInterfaces();
- if (interfaces.size() == 1) {
- refinedType = interfaces.iterator().next();
+ DexType singleKnownInterface = classType.getInterfaces().getSingleKnownInterface();
+ if (singleKnownInterface != null) {
+ refinedType = singleKnownInterface;
}
}
if (appView.appInfo().isSubtype(refinedType, staticReceiverType)) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeElement.java
index a2c8d57..9736b13 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeElement.java
@@ -147,11 +147,7 @@
* @return {@code true} if {@param this} is strictly less than {@param other}.
*/
public boolean strictlyLessThan(TypeElement other, AppView<?> appView) {
- if (equals(other)) {
- return false;
- }
- TypeElement lub = join(other, appView);
- return !equals(lub) && other.equals(lub);
+ return !equals(other) && internalLessThan(other, appView);
}
/**
@@ -163,7 +159,13 @@
* @return {@code true} if {@param this} is less than or equal to {@param other}.
*/
public boolean lessThanOrEqual(TypeElement other, AppView<?> appView) {
- return equals(other) || strictlyLessThan(other, appView);
+ return equals(other) || internalLessThan(other, appView);
+ }
+
+ private boolean internalLessThan(TypeElement other, AppView<?> appView) {
+ // The equals check has already been done by callers, so only the join is computed.
+ TypeElement lub = join(other, appView);
+ return !equals(lub) && other.equals(lub);
}
/**
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index a1c4e7b..d0e0027 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -227,9 +227,9 @@
for (Value value : current.inValues()) {
value.removeUser(current);
}
- if (current.outValue() != null && current.outValue().isUsed()) {
+ if (current.hasUsedOutValue()) {
assert newInstruction.outValue() != null;
- if (affectedValues != null) {
+ if (affectedValues != null && newInstruction.getOutType() != current.getOutType()) {
current.outValue().addAffectedValuesTo(affectedValues);
}
current.outValue().replaceUsers(newInstruction.outValue());
@@ -243,6 +243,7 @@
listIterator.add(newInstruction);
current.clearBlock();
metadata.record(newInstruction);
+ current = newInstruction;
}
@Override
@@ -402,6 +403,69 @@
}
@Override
+ public void replaceCurrentInstructionWithThrow(
+ AppView<?> appView,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ Value exceptionValue,
+ Set<BasicBlock> blocksToRemove,
+ Set<Value> affectedValues) {
+ if (current == null) {
+ throw new IllegalStateException();
+ }
+
+ Instruction toBeReplaced = current;
+ InternalOptions options = appView.options();
+
+ BasicBlock block = toBeReplaced.getBlock();
+ assert !blocksToRemove.contains(block);
+ assert affectedValues != null;
+
+ // Split the block before the instruction that should be replaced by `throw exceptionValue`.
+ previous();
+
+ BasicBlock throwBlock;
+ if (block.hasCatchHandlers() && !toBeReplaced.instructionTypeCanThrow()) {
+ // We need to insert the throw instruction in a block of its own, so split the current block
+ // into three blocks, where the intermediate block only contains a goto instruction.
+ throwBlock = splitCopyCatchHandlers(code, blockIterator, options);
+ throwBlock.listIterator(code).split(code, blockIterator, true);
+ } else {
+ splitCopyCatchHandlers(code, blockIterator, options);
+ throwBlock = block;
+ }
+
+ // Unlink all blocks that are dominated by the unique normal successor of the throw block.
+ blocksToRemove.addAll(
+ throwBlock.unlink(
+ throwBlock.getUniqueNormalSuccessor(),
+ new DominatorTree(code, MAY_HAVE_UNREACHABLE_BLOCKS),
+ affectedValues));
+
+ InstructionListIterator throwBlockInstructionIterator;
+ if (throwBlock == block) {
+ throwBlockInstructionIterator = this;
+ previous();
+ next();
+ } else {
+ throwBlockInstructionIterator = throwBlock.listIterator(code, 1);
+ }
+ assert !throwBlockInstructionIterator.hasNext();
+
+ // Replace the instruction by throw.
+ Throw throwInstruction = new Throw(exceptionValue);
+ if (hasInsertionPosition()) {
+ throwInstruction.setPosition(position);
+ } else if (toBeReplaced.getPosition().isSome()) {
+ throwInstruction.setPosition(toBeReplaced.getPosition());
+ } else {
+ assert !toBeReplaced.instructionTypeCanThrow();
+ throwInstruction.setPosition(Position.syntheticNone());
+ }
+ throwBlockInstructionIterator.replaceCurrentInstruction(throwInstruction);
+ }
+
+ @Override
public void replaceCurrentInstructionWithThrowNull(
AppView<? extends AppInfoWithClassHierarchy> appView,
IRCode code,
@@ -563,8 +627,9 @@
IRCode code, ListIterator<BasicBlock> blockIterator, InternalOptions options) {
BasicBlock splitBlock = split(code, blockIterator, false);
assert !block.hasCatchHandlers();
- assert splitBlock.hasCatchHandlers();
- block.copyCatchHandlers(code, blockIterator, splitBlock, options);
+ if (splitBlock.hasCatchHandlers()) {
+ block.copyCatchHandlers(code, blockIterator, splitBlock, options);
+ }
return splitBlock;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
index 7ec3198..fa42fcd 100644
--- a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
@@ -64,8 +64,18 @@
public boolean instructionInstanceCanThrow(
AppView<?> appView, ProgramMethod context, SideEffectAssumption assumption) {
- SuccessfulFieldResolutionResult resolutionResult =
- appView.appInfo().resolveField(field, context).asSuccessfulResolution();
+ return internalInstructionInstanceCanThrow(
+ appView,
+ context,
+ assumption,
+ appView.appInfo().resolveField(field, context).asSuccessfulResolution());
+ }
+
+ boolean internalInstructionInstanceCanThrow(
+ AppView<?> appView,
+ ProgramMethod context,
+ SideEffectAssumption assumption,
+ SuccessfulFieldResolutionResult resolutionResult) {
if (resolutionResult == null) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index 01cf2ba..efc52d1 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -596,9 +596,13 @@
if (instruction.outValue != null && instruction.outValue.getType().isClassType()) {
ClassTypeElement classTypeLattice = instruction.outValue.getType().asClassType();
assert !verticallyMergedClasses.hasBeenMergedIntoSubtype(classTypeLattice.getClassType());
- for (DexType itf : classTypeLattice.getInterfaces()) {
- assert !verticallyMergedClasses.hasBeenMergedIntoSubtype(itf);
- }
+ assert !classTypeLattice
+ .getInterfaces()
+ .anyMatch(
+ (itf, isKnown) -> {
+ assert !verticallyMergedClasses.hasBeenMergedIntoSubtype(itf);
+ return false;
+ });
}
}
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
index 757a581..4e223924 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
@@ -85,6 +85,17 @@
}
@Override
+ public void replaceCurrentInstructionWithThrow(
+ AppView<?> appView,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ Value exceptionValue,
+ Set<BasicBlock> blocksToRemove,
+ Set<Value> affectedValues) {
+ throw new Unimplemented();
+ }
+
+ @Override
public void replaceCurrentInstructionWithThrowNull(
AppView<? extends AppInfoWithClassHierarchy> appView,
IRCode code,
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
index c38c5c0..20377f3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
@@ -121,12 +122,13 @@
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
AppInfoWithLiveness appInfoWithLiveness = appViewWithLiveness.appInfo();
- if (instructionInstanceCanThrow(appView, context, assumption)) {
+ SuccessfulFieldResolutionResult resolutionResult =
+ appInfoWithLiveness.resolveField(getField()).asSuccessfulResolution();
+ if (internalInstructionInstanceCanThrow(appView, context, assumption, resolutionResult)) {
return true;
}
- DexEncodedField encodedField =
- appInfoWithLiveness.resolveField(getField()).getResolvedField();
+ DexEncodedField encodedField = resolutionResult.getResolvedField();
assert encodedField != null : "NoSuchFieldError (resolution failure) should be caught.";
if (encodedField.type().isAlwaysNull(appViewWithLiveness)) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
index 6b17a04..32b1f29 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
@@ -120,6 +120,14 @@
void replaceCurrentInstructionWithStaticGet(
AppView<?> appView, IRCode code, DexField field, Set<Value> affectedValues);
+ void replaceCurrentInstructionWithThrow(
+ AppView<?> appView,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ Value exceptionValue,
+ Set<BasicBlock> blocksToRemove,
+ Set<Value> affectedValues);
+
/**
* Replace the current instruction with null throwing instructions.
*
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java b/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
index 29b8a3b..1ef9cf5 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
@@ -12,6 +12,8 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection.Builder;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.conversion.CfBuilder;
@@ -19,9 +21,7 @@
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.InliningConstraints;
-import com.google.common.collect.ImmutableSet;
import java.util.List;
-import java.util.Set;
public final class InvokeCustom extends Invoke {
@@ -44,19 +44,18 @@
}
private static boolean verifyLambdaInterfaces(
- TypeElement returnType, Set<DexType> lambdaInterfaceSet, DexType objectType) {
- Set<DexType> primaryInterfaces = returnType.asClassType().getInterfaces();
+ TypeElement returnType, InterfaceCollection lambdaInterfaceSet, DexType objectType) {
+ InterfaceCollection primaryInterfaces = returnType.asClassType().getInterfaces();
if (returnType.asClassType().getClassType() == objectType) {
- assert primaryInterfaces.size() == 1;
// The interfaces returned by the LambdaDescriptor assumed to already contain the primary
// interface. If they're both singleton lists they must be identical and we can return the
// primary return type.
- assert lambdaInterfaceSet.contains(primaryInterfaces.iterator().next());
+ assert lambdaInterfaceSet.containsKnownInterface(primaryInterfaces.getSingleKnownInterface());
} else {
// We arrive here if the primary interface is a missing class. In that case the
// returnType will be the missing type as the class type.
assert primaryInterfaces.isEmpty();
- assert lambdaInterfaceSet.contains(returnType.asClassType().getClassType());
+ assert lambdaInterfaceSet.containsKnownInterface(returnType.asClassType().getClassType());
}
return true;
}
@@ -76,20 +75,21 @@
// The primary return type is either an interface or a missing type.
assert returnType instanceof ClassTypeElement;
- Set<DexType> primaryInterfaces = returnType.asClassType().getInterfaces();
+ InterfaceCollection primaryInterfaces = returnType.asClassType().getInterfaces();
DexType objectType = appView.dexItemFactory().objectType;
if (returnType.asClassType().getClassType() == objectType) {
- assert primaryInterfaces.size() == 1;
+ assert primaryInterfaces.hasSingleKnownInterface();
// Shortcut for the common case: single interface. Save creating a new lattice type.
if (lambdaInterfaces.size() == 1) {
- assert lambdaInterfaces.get(0) == primaryInterfaces.iterator().next();
+ assert lambdaInterfaces.get(0) == primaryInterfaces.getSingleKnownInterface();
return returnType;
}
}
- Set<DexType> lambdaInterfaceSet =
- ImmutableSet.<DexType>builder().addAll(lambdaInterfaces).build();
+ Builder builder = InterfaceCollection.builder();
+ lambdaInterfaces.forEach(iface -> builder.addInterface(iface, true));
+ InterfaceCollection lambdaInterfaceSet = builder.build();
assert verifyLambdaInterfaces(returnType, lambdaInterfaceSet, objectType);
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
index 9d7d69b..0d9d21a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.code;
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
import com.android.tools.r8.cf.LoadStoreHelper;
import com.android.tools.r8.cf.TypeVerificationHelper;
@@ -21,6 +22,7 @@
import com.android.tools.r8.ir.analysis.modeling.LibraryMethodReadSetModeling;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.UnknownValue;
import com.android.tools.r8.ir.optimize.DefaultInliningOracle;
@@ -253,6 +255,11 @@
return self();
}
+ public B setFreshOutValue(AppView<?> appView, ValueFactory factory) {
+ return super.setFreshOutValue(
+ factory, TypeElement.fromDexType(method.getReturnType(), maybeNull(), appView));
+ }
+
public B setSingleArgument(Value argument) {
return setArguments(ImmutableList.of(argument));
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
index bbb6d27..3e61866 100644
--- a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
@@ -100,6 +100,18 @@
}
@Override
+ public void replaceCurrentInstructionWithThrow(
+ AppView<?> appView,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ Value exceptionValue,
+ Set<BasicBlock> blocksToRemove,
+ Set<Value> affectedValues) {
+ currentBlockIterator.replaceCurrentInstructionWithThrow(
+ appView, code, blockIterator, exceptionValue, blocksToRemove, affectedValues);
+ }
+
+ @Override
public void replaceCurrentInstructionWithThrowNull(
AppView<? extends AppInfoWithClassHierarchy> appView,
IRCode code,
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
index 82d67b0..1017f53 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
@@ -28,7 +29,6 @@
import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.ir.regalloc.RegisterAllocator;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.ProguardMemberRule;
public class StaticPut extends FieldInstruction implements StaticFieldInstruction {
@@ -99,22 +99,14 @@
if (appView.appInfo().hasLiveness()) {
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
AppInfoWithLiveness appInfoWithLiveness = appViewWithLiveness.appInfo();
- // MemberValuePropagation will replace the field read only if the target field has bound
- // -assumevalues rule whose return value is *single*.
- //
- // Note that, in principle, class initializer of the field's holder may have side effects.
- // However, with -assumevalues, we assume that the developer wants to remove field accesses.
- ProguardMemberRule rule = appInfoWithLiveness.assumedValues.get(getField());
- if (rule != null && rule.getReturnValue().isSingleValue()) {
- return false;
- }
- if (instructionInstanceCanThrow(appView, context, assumption)) {
+ SuccessfulFieldResolutionResult resolutionResult =
+ appInfoWithLiveness.resolveField(getField()).asSuccessfulResolution();
+ if (internalInstructionInstanceCanThrow(appView, context, assumption, resolutionResult)) {
return true;
}
- DexEncodedField encodedField =
- appInfoWithLiveness.resolveField(getField()).getResolvedField();
+ DexEncodedField encodedField = resolutionResult.getResolvedField();
assert encodedField != null : "NoSuchFieldError (resolution failure) should be caught.";
boolean isDeadProtoExtensionField =
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
index de727c4..5df390f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
@@ -407,7 +407,7 @@
if (!getMethod().isStatic()) {
firstLocalIndex++;
}
- for (DexType value : getMethod().proto().parameters.values) {
+ for (DexType value : getMethod().getProto().parameters.values) {
firstLocalIndex++;
if (value.isLongType() || value.isDoubleType()) {
firstLocalIndex++;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
new file mode 100644
index 0000000..e747891
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
@@ -0,0 +1,115 @@
+// 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.ir.conversion;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+public abstract class ClassConverter {
+
+ private final IRConverter converter;
+ private final D8MethodProcessor methodProcessor;
+
+ ClassConverter(IRConverter converter, D8MethodProcessor methodProcessor) {
+ this.converter = converter;
+ this.methodProcessor = methodProcessor;
+ }
+
+ public static ClassConverter create(
+ AppView<?> appView, IRConverter converter, D8MethodProcessor methodProcessor) {
+ return appView.options().desugarSpecificOptions().allowAllDesugaredInput
+ ? new LibraryDesugaredClassConverter(appView, converter, methodProcessor)
+ : new DefaultClassConverter(converter, methodProcessor);
+ }
+
+ public void convertClasses(DexApplication application, ExecutorService executorService)
+ throws ExecutionException {
+ internalConvertClasses(application, executorService);
+ notifyAllClassesConverted();
+ }
+
+ private void internalConvertClasses(DexApplication application, ExecutorService executorService)
+ throws ExecutionException {
+ List<DexProgramClass> classes = application.classes();
+ while (!classes.isEmpty()) {
+ Set<DexType> seenNestHosts = Sets.newIdentityHashSet();
+ List<DexProgramClass> deferred = new ArrayList<>(classes.size() / 2);
+ List<DexProgramClass> wave = new ArrayList<>(classes.size());
+ for (DexProgramClass clazz : classes) {
+ if (clazz.isInANest() && !seenNestHosts.add(clazz.getNestHost())) {
+ deferred.add(clazz);
+ } else {
+ wave.add(clazz);
+ }
+ }
+ ThreadUtils.processItems(wave, this::convertClass, executorService);
+ classes = deferred;
+ }
+ methodProcessor.awaitMethodProcessing();
+ }
+
+ abstract void convertClass(DexProgramClass clazz);
+
+ void convertMethods(DexProgramClass clazz) {
+ converter.convertMethods(clazz, methodProcessor);
+ }
+
+ abstract void notifyAllClassesConverted();
+
+ static class DefaultClassConverter extends ClassConverter {
+
+ DefaultClassConverter(IRConverter converter, D8MethodProcessor methodProcessor) {
+ super(converter, methodProcessor);
+ }
+
+ @Override
+ void convertClass(DexProgramClass clazz) {
+ convertMethods(clazz);
+ }
+
+ @Override
+ void notifyAllClassesConverted() {
+ // Intentionally empty.
+ }
+ }
+
+ static class LibraryDesugaredClassConverter extends ClassConverter {
+
+ private final AppView<?> appView;
+ private final Set<DexType> alreadyLibraryDesugared = Sets.newConcurrentHashSet();
+
+ LibraryDesugaredClassConverter(
+ AppView<?> appView, IRConverter converter, D8MethodProcessor methodProcessor) {
+ super(converter, methodProcessor);
+ this.appView = appView;
+ }
+
+ @Override
+ void convertClass(DexProgramClass clazz) {
+ // Classes which has already been through library desugaring will not go through IR
+ // processing again.
+ LibraryDesugaredChecker libraryDesugaredChecker = new LibraryDesugaredChecker(appView);
+ if (libraryDesugaredChecker.isClassLibraryDesugared(clazz)) {
+ alreadyLibraryDesugared.add(clazz.getType());
+ } else {
+ convertMethods(clazz);
+ }
+ }
+
+ @Override
+ void notifyAllClassesConverted() {
+ appView.setAlreadyLibraryDesugared(alreadyLibraryDesugared);
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
new file mode 100644
index 0000000..61ea47c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.conversion;
+
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
+import com.android.tools.r8.utils.ThreadUtils;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+public class D8MethodProcessor extends MethodProcessor {
+
+ private final IRConverter converter;
+ private final ExecutorService executorService;
+ private final List<Future<?>> futures = Collections.synchronizedList(new ArrayList<>());
+
+ public D8MethodProcessor(IRConverter converter, ExecutorService executorService) {
+ this.converter = converter;
+ this.executorService = executorService;
+ }
+
+ public void awaitMethodProcessing() throws ExecutionException {
+ ThreadUtils.awaitFutures(futures);
+ futures.clear();
+ }
+
+ @Override
+ public boolean shouldApplyCodeRewritings(ProgramMethod method) {
+ return true;
+ }
+
+ @Override
+ public void scheduleMethodForProcessingAfterCurrentWave(ProgramMethod method) {
+ futures.add(
+ ThreadUtils.processAsynchronously(
+ () ->
+ converter.rewriteCode(method, OptimizationFeedbackIgnore.getInstance(), this, null),
+ executorService));
+ }
+
+ public boolean verifyAllMethodsProcessed() {
+ assert futures.isEmpty();
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 27a8c72..1bee2d4 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -2402,7 +2402,7 @@
}
// Move all normal successors to the new block.
- currentBlockInfo.normalSuccessors.forEach((Integer offset) -> info.addNormalSuccessor(offset));
+ currentBlockInfo.normalSuccessors.forEach(info::addNormalSuccessor);
currentBlockInfo.normalSuccessors.clear();
// Link the two blocks.
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index d08eb3e..dd9bee9 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -45,7 +45,6 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
import com.android.tools.r8.ir.desugar.CovariantReturnTypeAnnotationTransformer;
-import com.android.tools.r8.ir.desugar.D8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter.Mode;
import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
@@ -54,6 +53,8 @@
import com.android.tools.r8.ir.desugar.LambdaRewriter;
import com.android.tools.r8.ir.desugar.StringConcatRewriter;
import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
+import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
+import com.android.tools.r8.ir.desugar.nest.NestBridgeConsumer;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
import com.android.tools.r8.ir.optimize.AssumeInserter;
import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization;
@@ -108,12 +109,10 @@
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -240,7 +239,9 @@
new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS);
this.backportedMethodRewriter = new BackportedMethodRewriter(appView);
this.twrCloseResourceRewriter =
- enableTwrCloseResourceDesugaring() ? new TwrCloseResourceRewriter(appView, this) : null;
+ TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(appView.options())
+ ? new TwrCloseResourceRewriter(appView)
+ : null;
this.d8NestBasedAccessDesugaring =
options.shouldDesugarNests() ? new D8NestBasedAccessDesugaring(appView) : null;
this.lambdaMerger = null;
@@ -274,8 +275,9 @@
? new InterfaceMethodRewriter(appView, this)
: null;
this.twrCloseResourceRewriter =
- (options.desugarState == DesugarState.ON && enableTwrCloseResourceDesugaring())
- ? new TwrCloseResourceRewriter(appView, this)
+ (TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(options)
+ && !appView.enableWholeProgramOptimizations())
+ ? new TwrCloseResourceRewriter(appView)
: null;
this.backportedMethodRewriter =
(options.desugarState == DesugarState.ON && !appView.enableWholeProgramOptimizations())
@@ -322,7 +324,9 @@
this.identifierNameStringMarker = null;
}
this.devirtualizer =
- options.enableDevirtualization ? new Devirtualizer(appViewWithLiveness) : null;
+ options.enableDevirtualization
+ ? new Devirtualizer(appViewWithLiveness, mainDexClasses)
+ : null;
this.typeChecker = new TypeChecker(appViewWithLiveness, VerifyTypesHelper.create(appView));
this.d8NestBasedAccessDesugaring = null;
this.serviceLoaderRewriter =
@@ -382,38 +386,34 @@
this(AppView.createForD8(appInfo), timing, printer, MainDexTracingResult.NONE);
}
- private boolean enableTwrCloseResourceDesugaring() {
- return enableTryWithResourcesDesugaring() && !options.canUseTwrCloseResourceMethod();
- }
-
- private boolean enableTryWithResourcesDesugaring() {
- switch (options.tryWithResourcesDesugaring) {
- case Off:
- return false;
- case Auto:
- return !options.canUseSuppressedExceptions();
- }
- throw new Unreachable();
- }
-
private void removeLambdaDeserializationMethods() {
if (lambdaRewriter != null) {
lambdaRewriter.removeLambdaDeserializationMethods(appView.appInfo().classes());
}
}
- private void desugarNestBasedAccess(Builder<?> builder, ExecutorService executorService)
- throws ExecutionException {
+ private void synthesizeBridgesForNestBasedAccessesOnClasspath(
+ MethodProcessor methodProcessor, ExecutorService executorService) throws ExecutionException {
if (d8NestBasedAccessDesugaring != null) {
- d8NestBasedAccessDesugaring.desugarNestBasedAccess(builder, executorService, this);
+ d8NestBasedAccessDesugaring.synthesizeBridgesForNestBasedAccessesOnClasspath(
+ methodProcessor, executorService);
}
}
- private void synthesizeLambdaClasses(Builder<?> builder, ExecutorService executorService)
- throws ExecutionException {
+ private void finalizeNestBasedAccessDesugaring(Builder<?> builder) {
+ if (d8NestBasedAccessDesugaring != null) {
+ DexProgramClass nestConstructor = d8NestBasedAccessDesugaring.synthesizeNestConstructor();
+ if (nestConstructor != null) {
+ builder.addProgramClass(nestConstructor);
+ }
+ d8NestBasedAccessDesugaring.reportDesugarDependencies();
+ }
+ }
+
+ private void synthesizeLambdaClasses(ExecutorService executorService) throws ExecutionException {
if (lambdaRewriter != null) {
assert !appView.enableWholeProgramOptimizations();
- lambdaRewriter.finalizeLambdaDesugaringForD8(builder, this, executorService);
+ lambdaRewriter.finalizeLambdaDesugaringForD8(this, executorService);
}
}
@@ -435,16 +435,16 @@
Flavor includeAllResources,
ExecutorService executorService)
throws ExecutionException {
+ assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
if (interfaceMethodRewriter != null) {
interfaceMethodRewriter.desugarInterfaceMethods(
builder, includeAllResources, executorService);
}
}
- private void synthesizeTwrCloseResourceUtilityClass(
- Builder<?> builder, ExecutorService executorService) throws ExecutionException {
+ private void processTwrCloseResourceUtilityMethods() {
if (twrCloseResourceRewriter != null) {
- twrCloseResourceRewriter.synthesizeUtilityClass(builder, executorService, options);
+ twrCloseResourceRewriter.processSynthesizedMethods(this);
}
}
@@ -489,41 +489,27 @@
DexApplication application = appView.appInfo().app();
timing.begin("IR conversion");
- if (appView.options().desugarSpecificOptions().allowAllDesugaredInput) {
- // Classes which has already been through library desugaring will not go through IR
- // processing again.
- LibraryDesugaredChecker libraryDesugaredChecker = new LibraryDesugaredChecker(appView);
- Set<DexType> alreadyLibraryDesugared = Sets.newConcurrentHashSet();
- ThreadUtils.processItems(
- application.classes(),
- clazz -> {
- if (libraryDesugaredChecker.isClassLibraryDesugared(clazz)) {
- if (appView.options().desugarSpecificOptions().allowAllDesugaredInput) {
- alreadyLibraryDesugared.add(clazz.getType());
- } else {
- throw new CompilationError(
- "Code for "
- + clazz.getType().getDescriptor()
- + "has already been library desugared.");
- }
- } else {
- convertMethods(clazz);
- }
- },
- executor);
- appView.setAlreadyLibraryDesugared(alreadyLibraryDesugared);
- } else {
- ThreadUtils.processItems(application.classes(), this::convertMethods, executor);
- }
+ convertClasses(application, executor);
// Build a new application with jumbo string info,
- Builder<?> builder = application.builder();
- builder.setHighestSortingString(highestSortingString);
+ Builder<?> builder = application.builder().setHighestSortingString(highestSortingString);
- desugarNestBasedAccess(builder, executor);
- synthesizeLambdaClasses(builder, executor);
+ finalizeNestBasedAccessDesugaring(builder);
+
+ // Synthesize lambda classes and commit to the app in full.
+ synthesizeLambdaClasses(executor);
+ processTwrCloseResourceUtilityMethods();
+ if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
+ appView.setAppInfo(
+ new AppInfo(
+ appView.appInfo().getSyntheticItems().commit(builder.build()),
+ appView.appInfo().getMainDexClasses()));
+ application = appView.appInfo().app();
+ builder = application.builder();
+ builder.setHighestSortingString(highestSortingString);
+ }
+
desugarInterfaceMethods(builder, ExcludeDexResources, executor);
- synthesizeTwrCloseResourceUtilityClass(builder, executor);
processSynthesizedJava8UtilityClasses(executor);
synthesizeRetargetClass(builder, executor);
synthesizeInvokeSpecialBridges(executor);
@@ -532,14 +518,24 @@
timing.end();
- DexApplication app = builder.build();
+ application = builder.build();
appView.setAppInfo(
new AppInfo(
- appView.appInfo().getSyntheticItems().commit(app),
+ appView.appInfo().getSyntheticItems().commit(application),
appView.appInfo().getMainDexClasses()));
}
- private void convertMethods(DexProgramClass clazz) {
+ private void convertClasses(DexApplication application, ExecutorService executorService)
+ throws ExecutionException {
+ D8MethodProcessor methodProcessor = new D8MethodProcessor(this, executorService);
+ ClassConverter classConverter = ClassConverter.create(appView, this, methodProcessor);
+ classConverter.convertClasses(application, executorService);
+
+ synthesizeBridgesForNestBasedAccessesOnClasspath(methodProcessor, executorService);
+ methodProcessor.awaitMethodProcessing();
+ }
+
+ void convertMethods(DexProgramClass clazz, MethodProcessor methodProcessor) {
boolean isReachabilitySensitive = clazz.hasReachabilitySensitiveAnnotation(options.itemFactory);
// When converting all methods on a class always convert <clinit> first.
DexEncodedMethod classInitializer = clazz.getClassInitializer();
@@ -547,14 +543,14 @@
classInitializer
.getMutableOptimizationInfo()
.setReachabilitySensitive(isReachabilitySensitive);
- convertMethod(new ProgramMethod(clazz, classInitializer));
+ convertMethod(new ProgramMethod(clazz, classInitializer), methodProcessor);
}
clazz.forEachProgramMethodMatching(
definition -> !definition.isClassInitializer(),
method -> {
DexEncodedMethod definition = method.getDefinition();
definition.getMutableOptimizationInfo().setReachabilitySensitive(isReachabilitySensitive);
- convertMethod(method);
+ convertMethod(method, methodProcessor);
});
// The class file version is downgraded after compilation. Some of the desugaring might need
// the initial class file version to determine how far a method can be downgraded.
@@ -564,7 +560,7 @@
}
}
- private void convertMethod(ProgramMethod method) {
+ private void convertMethod(ProgramMethod method, MethodProcessor methodProcessor) {
DexEncodedMethod definition = method.getDefinition();
if (definition.hasClassFileVersion()) {
definition.downgradeClassFileVersion(
@@ -583,8 +579,7 @@
if (options.isGeneratingClassFiles()
|| !(options.passthroughDexCode && definition.getCode().isDexCode())) {
// We do not process in call graph order, so anything could be a leaf.
- rewriteCode(
- method, simpleOptimizationFeedback, OneTimeMethodProcessor.create(method, appView), null);
+ rewriteCode(method, simpleOptimizationFeedback, methodProcessor, null);
} else {
assert definition.getCode().isDexCode();
}
@@ -760,6 +755,7 @@
} else {
appView.setUnboxedEnums(EnumDataMap.empty());
}
+
if (!options.debug) {
new TrivialFieldAccessReprocessor(appView.withLiveness(), postMethodProcessorBuilder)
.run(executorService, feedback, timing);
@@ -768,7 +764,7 @@
timing.begin("IR conversion phase 2");
graphLensForIR = appView.graphLens();
PostMethodProcessor postMethodProcessor =
- postMethodProcessorBuilder.build(appView.withLiveness(), executorService, timing);
+ postMethodProcessorBuilder.build(appView, executorService, timing);
if (postMethodProcessor != null) {
assert !options.debug;
postMethodProcessor.forEachWaveWithExtension(feedback, executorService);
@@ -793,6 +789,14 @@
appView.clearCodeRewritings();
}
+ // Commit synthetics before creating a builder (otherwise the builder will not include the
+ // synthetics.)
+ if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
+ appView.setAppInfo(
+ appView
+ .appInfo()
+ .rebuildWithLiveness(appView.getSyntheticItems().commit(appView.appInfo().app())));
+ }
// Build a new application with jumbo string info.
Builder<?> builder = appView.appInfo().app().builder();
builder.setHighestSortingString(highestSortingString);
@@ -802,7 +806,6 @@
feedback.updateVisibleOptimizationInfo();
printPhase("Utility classes synthesis");
- synthesizeTwrCloseResourceUtilityClass(builder, executorService);
processSynthesizedJava8UtilityClasses(executorService);
synthesizeRetargetClass(builder, executorService);
synthesizeEnumUnboxingUtilityMethods(executorService);
@@ -814,11 +817,9 @@
printPhase("Desugared library API Conversion finalization");
generateDesugaredLibraryAPIWrappers(builder, executorService);
- if (serviceLoaderRewriter != null && serviceLoaderRewriter.getSynthesizedClass() != null) {
- appView.appInfo().addSynthesizedClass(serviceLoaderRewriter.getSynthesizedClass(), true);
+ if (serviceLoaderRewriter != null) {
processSynthesizedServiceLoaderMethods(
- serviceLoaderRewriter.getSynthesizedClass(), executorService);
- builder.addSynthesizedClass(serviceLoaderRewriter.getSynthesizedClass());
+ serviceLoaderRewriter.getServiceLoadMethods(), executorService);
}
// Update optimization info for all synthesized methods at once.
@@ -959,11 +960,10 @@
}
private void processSynthesizedServiceLoaderMethods(
- DexProgramClass synthesizedClass, ExecutorService executorService) throws ExecutionException {
+ List<ProgramMethod> serviceLoadMethods, ExecutorService executorService)
+ throws ExecutionException {
ThreadUtils.processItems(
- synthesizedClass::forEachProgramMethod,
- this::forEachSynthesizedServiceLoaderMethod,
- executorService);
+ serviceLoadMethods, this::forEachSynthesizedServiceLoaderMethod, executorService);
}
private void forEachSynthesizedServiceLoaderMethod(ProgramMethod method) {
@@ -1135,7 +1135,7 @@
}
}
- private Timing rewriteCode(
+ Timing rewriteCode(
ProgramMethod method,
OptimizationFeedback feedback,
MethodProcessor methodProcessor,
@@ -1162,7 +1162,7 @@
method.toSourceString(),
logCode(options, method.getDefinition()));
}
- boolean didDesugar = desugar(method);
+ boolean didDesugar = desugar(method, methodProcessor);
if (Log.ENABLED && didDesugar) {
Log.debug(
getClass(),
@@ -1185,7 +1185,7 @@
return optimize(code, feedback, methodProcessor, methodProcessingId);
}
- private boolean desugar(ProgramMethod method) {
+ private boolean desugar(ProgramMethod method, MethodProcessor methodProcessor) {
if (options.desugarState != DesugarState.ON) {
return false;
}
@@ -1194,13 +1194,17 @@
}
boolean didDesugar = false;
Supplier<AppInfoWithClassHierarchy> lazyAppInfo =
- Suppliers.memoize(() -> appView.appInfoForDesugaring());
+ Suppliers.memoize(appView::appInfoForDesugaring);
if (lambdaRewriter != null) {
didDesugar |= lambdaRewriter.desugarLambdas(method, lazyAppInfo.get()) > 0;
}
if (backportedMethodRewriter != null) {
didDesugar |= backportedMethodRewriter.desugar(method, lazyAppInfo.get());
}
+ if (d8NestBasedAccessDesugaring != null) {
+ NestBridgeConsumer bridgeConsumer = NestBridgeConsumer.createForD8(methodProcessor);
+ didDesugar |= d8NestBasedAccessDesugaring.desugar(method, bridgeConsumer);
+ }
return didDesugar;
}
@@ -1247,10 +1251,15 @@
timing.end();
}
- assert !method.isProcessed() || !isDebugMode;
+ assert !method.isProcessed() || !isDebugMode
+ : "Method already processed: "
+ + context.toSourceString()
+ + System.lineSeparator()
+ + ExceptionUtils.getMainStackTrace();
assert !method.isProcessed()
- || !appView.enableWholeProgramOptimizations()
- || !appView.appInfo().withLiveness().isNeverReprocessMethod(method.method);
+ || !appView.enableWholeProgramOptimizations()
+ || !appView.appInfo().withLiveness().isNeverReprocessMethod(method.method)
+ : "Illegal reprocessing due to -neverreprocess rule: " + context.toSourceString();
if (lambdaMerger != null) {
timing.begin("Merge lambdas");
@@ -1474,7 +1483,7 @@
deadCodeRemover.run(code, timing);
assert code.isConsistentSSA();
- if (options.desugarState == DesugarState.ON && enableTryWithResourcesDesugaring()) {
+ if (options.desugarState == DesugarState.ON && options.enableTryWithResourcesDesugaring()) {
timing.begin("Rewrite Throwable suppresed methods");
codeRewriter.rewriteThrowableAddAndGetSuppressed(code);
timing.end();
@@ -1530,18 +1539,9 @@
previous = printMethod(code, "IR after class inlining (SSA)", previous);
- if (d8NestBasedAccessDesugaring != null) {
- timing.begin("Desugar nest access");
- d8NestBasedAccessDesugaring.rewriteNestBasedAccesses(context, code, appView);
- timing.end();
- assert code.isConsistentSSA();
- }
-
- previous = printMethod(code, "IR after nest based access desugaring (SSA)", previous);
-
if (interfaceMethodRewriter != null) {
timing.begin("Rewrite interface methods");
- interfaceMethodRewriter.rewriteMethodReferences(code);
+ interfaceMethodRewriter.rewriteMethodReferences(code, methodProcessor, methodProcessingId);
timing.end();
assert code.isConsistentSSA();
}
@@ -1550,7 +1550,8 @@
// This pass has to be after interfaceMethodRewriter and BackportedMethodRewriter.
if (desugaredLibraryAPIConverter != null
- && (!appView.enableWholeProgramOptimizations() || methodProcessor.isPrimary())) {
+ && (!appView.enableWholeProgramOptimizations()
+ || methodProcessor.isPrimaryMethodProcessor())) {
timing.begin("Desugar library API");
desugaredLibraryAPIConverter.desugar(code);
timing.end();
@@ -1561,7 +1562,7 @@
if (twrCloseResourceRewriter != null) {
timing.begin("Rewrite TWR close");
- twrCloseResourceRewriter.rewriteMethodCode(code);
+ twrCloseResourceRewriter.rewriteIR(code);
timing.end();
}
@@ -1580,7 +1581,7 @@
// TODO(b/140766440): an ideal solution would be puttting CodeOptimization for this into
// the list for primary processing only.
- if (options.outline.enabled && outliner != null && methodProcessor.isPrimary()) {
+ if (options.outline.enabled && outliner != null && methodProcessor.isPrimaryMethodProcessor()) {
timing.begin("Identify outlines");
outliner.getOutlineMethodIdentifierGenerator().accept(code);
timing.end();
@@ -1633,7 +1634,7 @@
timing.end();
}
- if (enumUnboxer != null && methodProcessor.isPrimary()) {
+ if (enumUnboxer != null && methodProcessor.isPrimaryMethodProcessor()) {
enumUnboxer.analyzeEnums(code);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
index 86ff63f..ef9a31c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
@@ -8,25 +8,13 @@
public abstract class MethodProcessor {
- public enum Phase {
- ONE_TIME,
- PRIMARY,
- POST
- }
-
protected SortedProgramMethodSet wave;
protected SortedProgramMethodSet waveExtension = SortedProgramMethodSet.createConcurrent();
- public abstract Phase getPhase();
-
public abstract boolean shouldApplyCodeRewritings(ProgramMethod method);
- public boolean isPrimary() {
- return getPhase() == Phase.PRIMARY;
- }
-
- public boolean isPost() {
- return getPhase() == Phase.POST;
+ public boolean isPrimaryMethodProcessor() {
+ return false;
}
public CallSiteInformation getCallSiteInformation() {
@@ -41,7 +29,7 @@
waveExtension.add(method);
}
- protected final void prepareForWaveExtensionProcessing() {
+ protected void prepareForWaveExtensionProcessing() {
if (waveExtension.isEmpty()) {
wave = SortedProgramMethodSet.empty();
} else {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
index f348214..c44ce41 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
@@ -18,7 +18,7 @@
class NeedsIRDesugarUseRegistry extends UseRegistry {
- private boolean needsDesugarging = false;
+ private boolean needsDesugaring = false;
private final AppView appView;
private final BackportedMethodRewriter backportedMethodRewriter;
private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
@@ -40,15 +40,15 @@
}
public boolean needsDesugaring() {
- return needsDesugarging;
+ return needsDesugaring;
}
@Override
public void registerInitClass(DexType type) {
- if (!needsDesugarging
+ if (!needsDesugaring
&& desugaredLibraryAPIConverter != null
&& desugaredLibraryAPIConverter.canConvert(type)) {
- needsDesugarging = true;
+ needsDesugaring = true;
}
}
@@ -67,31 +67,38 @@
registerDesugaredLibraryAPIConverter(method);
}
+ private void registerTwrCloseResourceRewriting(DexMethod method) {
+ if (!needsDesugaring) {
+ needsDesugaring =
+ TwrCloseResourceRewriter.isTwrCloseResourceMethod(method, appView.dexItemFactory());
+ }
+ }
+
private void registerBackportedMethodRewriting(DexMethod method) {
- if (!needsDesugarging) {
- needsDesugarging = backportedMethodRewriter.needsDesugaring(method);
+ if (!needsDesugaring) {
+ needsDesugaring = backportedMethodRewriter.needsDesugaring(method);
}
}
private void registerInterfaceMethodRewriting(DexMethod method, boolean isInvokeSuper) {
- if (!needsDesugarging) {
- needsDesugarging =
+ if (!needsDesugaring) {
+ needsDesugaring =
interfaceMethodRewriter != null
&& interfaceMethodRewriter.needsRewriting(method, isInvokeSuper, appView);
}
}
private void registerDesugaredLibraryAPIConverter(DexMethod method) {
- if (!needsDesugarging) {
- needsDesugarging =
+ if (!needsDesugaring) {
+ needsDesugaring =
desugaredLibraryAPIConverter != null
&& desugaredLibraryAPIConverter.shouldRewriteInvoke(method);
}
}
private void registerLibraryRetargeting(DexMethod method, boolean b) {
- if (!needsDesugarging) {
- needsDesugarging =
+ if (!needsDesugaring) {
+ needsDesugaring =
desugaredLibraryRetargeter != null
&& desugaredLibraryRetargeter.getRetargetedMethod(method, b) != null;
}
@@ -99,9 +106,7 @@
@Override
public void registerInvokeStatic(DexMethod method) {
- if (!needsDesugarging) {
- needsDesugarging = TwrCloseResourceRewriter.isSynthesizedCloseResourceMethod(method, appView);
- }
+ registerTwrCloseResourceRewriting(method);
registerBackportedMethodRewriting(method);
registerLibraryRetargeting(method, false);
registerInterfaceMethodRewriting(method, false);
@@ -118,7 +123,7 @@
@Override
public void registerInvokeStatic(DexMethod method, boolean itf) {
if (itf) {
- needsDesugarging = true;
+ needsDesugaring = true;
}
registerInvokeStatic(method);
}
@@ -126,7 +131,7 @@
@Override
public void registerCallSite(DexCallSite callSite) {
super.registerCallSite(callSite);
- needsDesugarging = true;
+ needsDesugaring = true;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
index bb3f07c..a8c2e57 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
@@ -52,11 +52,6 @@
return true;
}
- @Override
- public Phase getPhase() {
- return Phase.ONE_TIME;
- }
-
public <E extends Exception> void forEachWaveWithExtension(
ThrowingBiConsumer<ProgramMethod, MethodProcessingId, E> consumer) throws E {
while (!wave.isEmpty()) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
index 3d86936..649edfd 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
@@ -37,14 +37,14 @@
private final AppView<AppInfoWithLiveness> appView;
private final Collection<CodeOptimization> defaultCodeOptimizations;
- private final Map<DexEncodedMethod, Collection<CodeOptimization>> methodsMap;
+ private final Map<DexMethod, Collection<CodeOptimization>> methodsMap;
private final Deque<SortedProgramMethodSet> waves;
private final ProgramMethodSet processed = ProgramMethodSet.create();
private PostMethodProcessor(
AppView<AppInfoWithLiveness> appView,
Collection<CodeOptimization> defaultCodeOptimizations,
- Map<DexEncodedMethod, Collection<CodeOptimization>> methodsMap,
+ Map<DexMethod, Collection<CodeOptimization>> methodsMap,
CallGraph callGraph) {
this.appView = appView;
this.defaultCodeOptimizations = defaultCodeOptimizations;
@@ -53,11 +53,6 @@
}
@Override
- public Phase getPhase() {
- return Phase.POST;
- }
-
- @Override
public boolean shouldApplyCodeRewritings(ProgramMethod method) {
assert !wave.contains(method);
return !processed.contains(method);
@@ -68,7 +63,7 @@
private final Collection<CodeOptimization> defaultCodeOptimizations;
private final LongLivedProgramMethodSetBuilder<?> methodsToReprocess =
LongLivedProgramMethodSetBuilder.createForIdentitySet();
- private final Map<DexEncodedMethod, Collection<CodeOptimization>> optimizationsMap =
+ private final Map<DexMethod, Collection<CodeOptimization>> optimizationsMap =
new IdentityHashMap<>();
Builder(Collection<CodeOptimization> defaultCodeOptimizations) {
@@ -85,7 +80,7 @@
methodsToReprocess.add(method);
optimizationsMap
.computeIfAbsent(
- method.getDefinition(),
+ method.getReference(),
// Optimization order might matter, hence a collection that preserves orderings.
k -> new LinkedHashSet<>())
.addAll(codeOptimizations);
@@ -110,13 +105,11 @@
// according to the graph lens.
public void rewrittenWithLens(AppView<AppInfoWithLiveness> appView, GraphLens applied) {
methodsToReprocess.rewrittenWithLens(appView, applied);
- Map<DexEncodedMethod, Collection<CodeOptimization>> newOptimizationsMap =
- new IdentityHashMap<>();
+ Map<DexMethod, Collection<CodeOptimization>> newOptimizationsMap = new IdentityHashMap<>();
optimizationsMap.forEach(
(method, optimizations) ->
newOptimizationsMap.put(
- appView.graphLens().mapDexEncodedMethod(method, appView, applied),
- optimizations));
+ appView.graphLens().getRenamedMethodSignature(method, applied), optimizations));
optimizationsMap.clear();
optimizationsMap.putAll(newOptimizationsMap);
}
@@ -164,9 +157,13 @@
}
@Override
- public void scheduleMethodForProcessingAfterCurrentWave(ProgramMethod method) {
- super.scheduleMethodForProcessingAfterCurrentWave(method);
- methodsMap.put(method.getDefinition(), defaultCodeOptimizations);
+ protected void prepareForWaveExtensionProcessing() {
+ waveExtension.forEach(
+ method -> {
+ assert !methodsMap.containsKey(method.getReference());
+ methodsMap.put(method.getReference(), defaultCodeOptimizations);
+ });
+ super.prepareForWaveExtensionProcessing();
}
void forEachWaveWithExtension(OptimizationFeedback feedback, ExecutorService executorService)
@@ -182,7 +179,7 @@
wave,
(method, index) -> {
Collection<CodeOptimization> codeOptimizations =
- methodsMap.get(method.getDefinition());
+ methodsMap.get(method.getReference());
assert codeOptimizations != null && !codeOptimizations.isEmpty();
forEachMethod(
method, codeOptimizations, feedback, methodProcessingIds.get(method, index));
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
index dd4c0a0..cb288b0 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
@@ -62,8 +62,8 @@
}
@Override
- public Phase getPhase() {
- return Phase.PRIMARY;
+ public boolean isPrimaryMethodProcessor() {
+ return true;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 40b18c9..994e2ba 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -7,7 +7,6 @@
import com.android.tools.r8.cf.code.CfInstruction;
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.dex.ApplicationReader;
-import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
@@ -17,7 +16,6 @@
import com.android.tools.r8.graph.DexApplication;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexProto;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
@@ -33,12 +31,16 @@
import com.android.tools.r8.ir.desugar.backports.NumericMethodRewrites;
import com.android.tools.r8.ir.desugar.backports.ObjectsMethodRewrites;
import com.android.tools.r8.ir.desugar.backports.OptionalMethodRewrites;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.IntBox;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.DesugarState;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.Timing;
+import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
@@ -51,6 +53,7 @@
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.function.Consumer;
+import java.util.function.Supplier;
import org.objectweb.asm.Opcodes;
public final class BackportedMethodRewriter {
@@ -128,6 +131,14 @@
}
CfCode code = method.getDefinition().getCode().asCfCode();
ListIterator<CfInstruction> iterator = code.getInstructions().listIterator();
+ // TODO(b/172194101): Make this part of a unique context construction.
+ IntBox nextBackportId = new IntBox();
+ Supplier<String> methodIdSupplier =
+ () -> {
+ Hasher hasher = Hashing.sha256().newHasher();
+ method.getReference().hash(hasher);
+ return "$" + hasher.hash().toString() + "$" + nextBackportId.getAndIncrement();
+ };
boolean replaced = false;
while (iterator.hasNext()) {
CfInvoke invoke = iterator.next().asInvoke();
@@ -144,7 +155,7 @@
iterator = mutableInstructions.listIterator(iterator.previousIndex());
iterator.next();
}
- provider.rewriteInvoke(invoke, iterator, method.getHolder(), appInfo, consumer);
+ provider.rewriteInvoke(invoke, iterator, method, appInfo, consumer, methodIdSupplier);
replaced = true;
}
}
@@ -1348,9 +1359,10 @@
public abstract void rewriteInvoke(
CfInvoke invoke,
ListIterator<CfInstruction> iterator,
- DexProgramClass context,
+ ProgramMethod context,
AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod);
+ Consumer<ProgramMethod> registerSynthesizedMethod,
+ Supplier<String> methodIdProvider);
}
private static final class InvokeRewriter extends MethodProvider {
@@ -1366,9 +1378,10 @@
public void rewriteInvoke(
CfInvoke invoke,
ListIterator<CfInstruction> iterator,
- DexProgramClass context,
+ ProgramMethod context,
AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod) {
+ Consumer<ProgramMethod> registerSynthesizedMethod,
+ Supplier<String> methodIdProvider) {
rewriter.rewrite(invoke, iterator, appInfo.dexItemFactory());
}
}
@@ -1392,31 +1405,33 @@
public void rewriteInvoke(
CfInvoke invoke,
ListIterator<CfInstruction> iterator,
- DexProgramClass context,
+ ProgramMethod context,
AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod) {
- ProgramMethod method = getSyntheticMethod(context, appInfo);
+ Consumer<ProgramMethod> registerSynthesizedMethod,
+ Supplier<String> methodIdProvider) {
+ ProgramMethod method = getSyntheticMethod(context, methodIdProvider, appInfo);
registerSynthesizedMethod.accept(method);
iterator.remove();
iterator.add(new CfInvoke(Opcodes.INVOKESTATIC, method.getReference(), false));
}
private ProgramMethod getSyntheticMethod(
- DexProgramClass context, AppInfoWithClassHierarchy appInfo) {
+ ProgramMethod context,
+ Supplier<String> methodIdProvider,
+ AppInfoWithClassHierarchy appInfo) {
return appInfo
.getSyntheticItems()
.createMethod(
+ SyntheticNaming.SyntheticKind.BACKPORT,
context,
appInfo.dexItemFactory(),
builder ->
builder
.setProto(getProto(appInfo.dexItemFactory()))
- .setAccessFlags(
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC,
- false))
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
.setCode(
- methodSig -> generateTemplateMethod(appInfo.app().options, methodSig)));
+ methodSig -> generateTemplateMethod(appInfo.app().options, methodSig)),
+ methodIdProvider);
}
public DexProto getProto(DexItemFactory itemFactory) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java
deleted file mode 100644
index 787915f..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/D8NestBasedAccessDesugaring.java
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.FieldInstruction;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.InvokeStatic;
-import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.utils.ThreadUtils;
-import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-
-// Summary:
-// - Process all methods compiled rewriting nest based access (Methods processed concurrently).
-// - Process classes on class path in reachable nests to find bridges to add
-// in Program classes (Nests processed concurrently).
-// - Add bridges and nest constructor class (Sequential).
-// - Optimize bridges (Bridges processed concurrently).
-public class D8NestBasedAccessDesugaring extends NestBasedAccessDesugaring {
-
- // Maps a nest host to a class met which has that nest host.
- // The value is used because the nest host might be missing.
- private final Map<DexType, DexProgramClass> metNestHosts = new ConcurrentHashMap<>();
-
- public D8NestBasedAccessDesugaring(AppView<?> appView) {
- super(appView);
- }
-
- public void rewriteNestBasedAccesses(ProgramMethod method, IRCode code, AppView<?> appView) {
- if (!method.getHolder().isInANest()) {
- return;
- }
- metNestHosts.put(method.getHolder().getNestHost(), method.getHolder());
-
- ListIterator<BasicBlock> blocks = code.listIterator();
- while (blocks.hasNext()) {
- BasicBlock block = blocks.next();
- InstructionListIterator instructions = block.listIterator(code);
- while (instructions.hasNext()) {
- Instruction instruction = instructions.next();
- if (instruction.isInvokeMethod()) {
- InvokeMethod invokeMethod = instruction.asInvokeMethod();
- DexMethod invokedMethod = invokeMethod.getInvokedMethod();
- if (!invokedMethod.holder.isClassType()) {
- continue;
- }
- // Since we only need to desugar accesses to private methods, and all accesses to private
- // methods must be accessing the private method directly on its holder, we can lookup the
- // method on the holder instead of resolving the method.
- DexClass holder = appView.definitionForHolder(invokedMethod);
- DexEncodedMethod definition = invokedMethod.lookupOnClass(holder);
- if (definition != null && invokeRequiresRewriting(definition, method)) {
- DexMethod bridge = ensureInvokeBridge(definition);
- if (definition.isInstanceInitializer()) {
- instructions.previous();
- Value extraNullValue =
- instructions.insertConstNullInstruction(code, appView.options());
- instructions.next();
- List<Value> parameters = new ArrayList<>(invokeMethod.arguments());
- parameters.add(extraNullValue);
- instructions.replaceCurrentInstruction(
- new InvokeDirect(bridge, invokeMethod.outValue(), parameters));
- } else {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(bridge, invokeMethod.outValue(), invokeMethod.arguments()));
- }
- }
- } else if (instruction.isFieldInstruction()) {
- // Since we only need to desugar accesses to private fields, and all accesses to private
- // fields must be accessing the private field directly on its holder, we can lookup the
- // field on the holder instead of resolving the field.
- FieldInstruction fieldInstruction = instruction.asFieldInstruction();
- DexClass holder = appView.definitionForHolder(fieldInstruction.getField());
- DexEncodedField field = fieldInstruction.getField().lookupOnClass(holder);
- if (field != null && fieldAccessRequiresRewriting(field, method)) {
- if (instruction.isInstanceGet() || instruction.isStaticGet()) {
- DexMethod bridge = ensureFieldAccessBridge(field, true);
- instructions.replaceCurrentInstruction(
- new InvokeStatic(bridge, instruction.outValue(), instruction.inValues()));
- } else {
- assert instruction.isInstancePut() || instruction.isStaticPut();
- DexMethod bridge = ensureFieldAccessBridge(field, false);
- instructions.replaceCurrentInstruction(
- new InvokeStatic(bridge, instruction.outValue(), instruction.inValues()));
- }
- }
- }
- }
- }
- }
-
- private void processNestsConcurrently(ExecutorService executorService) throws ExecutionException {
- List<Future<?>> futures = new ArrayList<>();
- for (DexProgramClass clazz : metNestHosts.values()) {
- futures.add(asyncProcessNest(clazz, executorService));
- }
- ThreadUtils.awaitFutures(futures);
- }
-
- private void addDeferredBridges() {
- addDeferredBridges(bridges.values());
- addDeferredBridges(getFieldBridges.values());
- addDeferredBridges(putFieldBridges.values());
- }
-
- private void addDeferredBridges(Collection<ProgramMethod> bridges) {
- for (ProgramMethod bridge : bridges) {
- bridge.getHolder().addMethod(bridge.getDefinition());
- }
- }
-
- private void optimizeDeferredBridgesConcurrently(
- ExecutorService executorService, IRConverter converter) throws ExecutionException {
- SortedProgramMethodSet methods = SortedProgramMethodSet.create();
- methods.addAll(bridges.values());
- methods.addAll(getFieldBridges.values());
- methods.addAll(putFieldBridges.values());
- converter.processMethodsConcurrently(methods, executorService);
- }
-
- public void desugarNestBasedAccess(
- DexApplication.Builder<?> builder, ExecutorService executorService, IRConverter converter)
- throws ExecutionException {
- if (metNestHosts.isEmpty()) {
- return;
- }
- processNestsConcurrently(executorService);
- addDeferredBridges();
- synthesizeNestConstructor(builder);
- optimizeDeferredBridgesConcurrently(executorService, converter);
- }
-
- // In D8, programClass are processed on the fly so they do not need to be processed again here.
- @Override
- protected boolean shouldProcessClassInNest(DexClass clazz, List<DexType> nest) {
- return clazz.isClasspathClass();
- }
-
- @Override
- void reportMissingNestHost(DexClass clazz) {
- appView.options().nestDesugaringWarningMissingNestHost(clazz);
- }
-
- @Override
- void reportIncompleteNest(List<DexType> nest) {
- appView.options().nestDesugaringWarningIncompleteNest(nest, appView);
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
index cf85276..860af39 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
@@ -178,7 +178,7 @@
|| definition.isLibraryMethodOverride().isFalse()) {
return false;
}
- if (!appView.rewritePrefix.hasRewrittenTypeInSignature(definition.proto(), appView)
+ if (!appView.rewritePrefix.hasRewrittenTypeInSignature(definition.getProto(), appView)
|| appView
.options()
.desugaredLibraryConfiguration
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
index 3dc74ac..a6606ed 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
@@ -43,6 +43,7 @@
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.WorkList;
import com.android.tools.r8.utils.collections.DexClassAndMethodSet;
@@ -64,6 +65,7 @@
public class DesugaredLibraryRetargeter {
+ private static final String RETARGET_PACKAGE = "retarget/";
public static final String DESUGAR_LIB_RETARGET_CLASS_NAME_PREFIX =
"$r8$retargetLibraryMember$virtualDispatch";
@@ -76,14 +78,27 @@
// Non final virtual library methods requiring generation of emulated dispatch.
private final DexClassAndMethodSet emulatedDispatchMethods = DexClassAndMethodSet.create();
+ private final String packageAndClassDescriptorPrefix;
+
public DesugaredLibraryRetargeter(AppView<?> appView) {
this.appView = appView;
+ packageAndClassDescriptorPrefix =
+ getRetargetPackageAndClassPrefixDescriptor(appView.options().desugaredLibraryConfiguration);
if (appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()) {
return;
}
new RetargetingSetup().setUpRetargeting();
}
+ public static boolean isRetargetType(DexType type, InternalOptions options) {
+ if (options.desugaredLibraryConfiguration == null) {
+ return false;
+ }
+ return type.toDescriptorString()
+ .startsWith(
+ getRetargetPackageAndClassPrefixDescriptor(options.desugaredLibraryConfiguration));
+ }
+
public static void checkForAssumedLibraryTypes(AppView<?> appView) {
Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
@@ -347,8 +362,10 @@
private class RetargetingSetup {
private void setUpRetargeting() {
+ DesugaredLibraryConfiguration desugaredLibraryConfiguration =
+ appView.options().desugaredLibraryConfiguration;
Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
- appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
+ desugaredLibraryConfiguration.getRetargetCoreLibMember();
for (DexString methodName : retargetCoreLibMember.keySet()) {
for (DexType inType : retargetCoreLibMember.get(methodName).keySet()) {
DexClass typeClass = appView.definitionFor(inType);
@@ -377,6 +394,22 @@
}
}
}
+ if (desugaredLibraryConfiguration.isLibraryCompilation()) {
+ // TODO(b/177977763): This is only a workaround rewriting invokes of j.u.Arrays.deepEquals0
+ // to j.u.DesugarArrays.deepEquals0.
+ DexItemFactory itemFactory = appView.options().dexItemFactory();
+ DexString name = itemFactory.createString("deepEquals0");
+ DexProto proto =
+ itemFactory.createProto(
+ itemFactory.booleanType, itemFactory.objectType, itemFactory.objectType);
+ DexMethod source =
+ itemFactory.createMethod(
+ itemFactory.createType(itemFactory.arraysDescriptor), proto, name);
+ DexMethod target =
+ itemFactory.createMethod(
+ itemFactory.createType("Ljava/util/DesugarArrays;"), proto, name);
+ retargetLibraryMember.put(source, target);
+ }
}
private boolean isEmulatedInterfaceDispatch(DexClassAndMethod method) {
@@ -668,14 +701,17 @@
return dispatchTypeFor(method, "dispatchHolder");
}
+ private static String getRetargetPackageAndClassPrefixDescriptor(
+ DesugaredLibraryConfiguration config) {
+ return "L"
+ + config.getSynthesizedLibraryClassesPackagePrefix()
+ + RETARGET_PACKAGE
+ + DESUGAR_LIB_RETARGET_CLASS_NAME_PREFIX;
+ }
+
private DexType dispatchTypeFor(DexClassAndMethod method, String suffix) {
String descriptor =
- "L"
- + appView
- .options()
- .desugaredLibraryConfiguration
- .getSynthesizedLibraryClassesPackagePrefix()
- + DESUGAR_LIB_RETARGET_CLASS_NAME_PREFIX
+ packageAndClassDescriptorPrefix
+ '$'
+ method.getHolderType().getName()
+ '$'
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 1529d2f..d2225e6 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.DesugarGraphConsumer;
import com.android.tools.r8.cf.CfVersion;
-import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.graph.AppInfo;
@@ -24,6 +23,7 @@
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexClasspathClass;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
@@ -36,9 +36,13 @@
import com.android.tools.r8.graph.DexValue;
import com.android.tools.r8.graph.GenericSignature;
import com.android.tools.r8.graph.GenericSignature.ClassSignature;
+import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.graph.MethodCollection;
+import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -49,18 +53,24 @@
import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.code.InvokeSuper;
+import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.conversion.MethodProcessingId;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
import com.android.tools.r8.ir.desugar.DefaultMethodsHelper.Collection;
import com.android.tools.r8.ir.desugar.InterfaceProcessor.InterfaceProcessorNestedGraphLens;
+import com.android.tools.r8.ir.optimize.UtilityMethodsForCodeOptimizations;
+import com.android.tools.r8.ir.optimize.UtilityMethodsForCodeOptimizations.UtilityMethodForCodeOptimizations;
import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.position.MethodPosition;
import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.IterableUtils;
-import com.android.tools.r8.utils.ObjectUtils;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
@@ -251,15 +261,21 @@
// Rewrites the references to static and default interface methods.
// NOTE: can be called for different methods concurrently.
- public void rewriteMethodReferences(IRCode code) {
+ public void rewriteMethodReferences(
+ IRCode code, MethodProcessor methodProcessor, MethodProcessingId methodProcessingId) {
ProgramMethod context = code.context();
if (synthesizedMethods.contains(context)) {
return;
}
+ Set<Value> affectedValues = Sets.newIdentityHashSet();
+ Set<BasicBlock> blocksToRemove = Sets.newIdentityHashSet();
ListIterator<BasicBlock> blocks = code.listIterator();
while (blocks.hasNext()) {
BasicBlock block = blocks.next();
+ if (blocksToRemove.contains(block)) {
+ continue;
+ }
InstructionListIterator instructions = block.listIterator(code);
while (instructions.hasNext()) {
Instruction instruction = instructions.next();
@@ -271,7 +287,15 @@
rewriteInvokeDirect(instruction.asInvokeDirect(), instructions, context);
break;
case INVOKE_STATIC:
- rewriteInvokeStatic(instruction.asInvokeStatic(), instructions, context);
+ rewriteInvokeStatic(
+ instruction.asInvokeStatic(),
+ code,
+ blocks,
+ instructions,
+ affectedValues,
+ blocksToRemove,
+ methodProcessor,
+ methodProcessingId);
break;
case INVOKE_SUPER:
rewriteInvokeSuper(instruction.asInvokeSuper(), instructions, context);
@@ -287,6 +311,14 @@
}
}
}
+
+ code.removeBlocks(blocksToRemove);
+
+ if (!affectedValues.isEmpty()) {
+ new TypeAnalysis(appView).narrowing(affectedValues);
+ }
+
+ assert code.isConsistentSSA();
}
private void rewriteInvokeCustom(InvokeCustom invoke, ProgramMethod context) {
@@ -327,16 +359,16 @@
getMethodOrigin(context.getReference()));
}
- DexEncodedMethod directTarget = clazz.lookupMethod(method);
+ DexClassAndMethod directTarget = clazz.lookupClassMethod(method);
if (directTarget != null) {
// This can be a private instance method call. Note that the referenced
// method is expected to be in the current class since it is private, but desugaring
// may move some methods or their code into other classes.
instructions.replaceCurrentInstruction(
new InvokeStatic(
- directTarget.isPrivateMethod()
- ? privateAsMethodOfCompanionClass(method)
- : defaultAsMethodOfCompanionClass(method),
+ directTarget.getDefinition().isPrivateMethod()
+ ? privateAsMethodOfCompanionClass(directTarget)
+ : defaultAsMethodOfCompanionClass(directTarget),
invoke.outValue(),
invoke.arguments()));
} else {
@@ -347,7 +379,7 @@
// This is a invoke-direct call to a virtual method.
instructions.replaceCurrentInstruction(
new InvokeStatic(
- defaultAsMethodOfCompanionClass(virtualTarget.getDefinition().method),
+ defaultAsMethodOfCompanionClass(virtualTarget),
invoke.outValue(),
invoke.arguments()));
} else {
@@ -359,13 +391,21 @@
}
private void rewriteInvokeStatic(
- InvokeStatic invoke, InstructionListIterator instructions, ProgramMethod context) {
+ InvokeStatic invoke,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ InstructionListIterator instructions,
+ Set<Value> affectedValues,
+ Set<BasicBlock> blocksToRemove,
+ MethodProcessor methodProcessor,
+ MethodProcessingId methodProcessingId) {
DexMethod invokedMethod = invoke.getInvokedMethod();
if (appView.getSyntheticItems().isPendingSynthetic(invokedMethod.holder)) {
// We did not create this code yet, but it will not require rewriting.
return;
}
+ ProgramMethod context = code.context();
DexClass clazz = appView.definitionFor(invokedMethod.holder, context);
if (clazz == null) {
// NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
@@ -406,17 +446,13 @@
appView
.getSyntheticItems()
.createMethod(
+ SyntheticNaming.SyntheticKind.STATIC_INTERFACE_CALL,
context.getHolder(),
factory,
syntheticMethodBuilder ->
syntheticMethodBuilder
.setProto(invokedMethod.proto)
- .setAccessFlags(
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC
- | Constants.ACC_STATIC
- | Constants.ACC_SYNTHETIC,
- false))
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
.setCode(
m ->
ForwardMethodBuilder.builder(factory)
@@ -436,13 +472,43 @@
// When leaving static interface method invokes upgrade the class file version.
context.getDefinition().upgradeClassFileVersion(CfVersion.V1_8);
}
- } else {
+ return;
+ }
+
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfoForDesugaring()
+ .resolveMethodOnInterface(clazz, invokedMethod)
+ .asSingleResolution();
+ if (resolutionResult != null && resolutionResult.getResolvedMethod().isStatic()) {
instructions.replaceCurrentInstruction(
new InvokeStatic(
- staticAsMethodOfCompanionClass(invokedMethod),
+ staticAsMethodOfCompanionClass(resolutionResult.getResolutionPair()),
invoke.outValue(),
invoke.arguments()));
+ return;
}
+
+ // Replace by throw new IncompatibleClassChangeError/NoSuchMethodError.
+ UtilityMethodForCodeOptimizations throwMethod =
+ resolutionResult == null
+ ? UtilityMethodsForCodeOptimizations.synthesizeThrowNoSuchMethodErrorMethod(
+ appView, context, methodProcessingId)
+ : UtilityMethodsForCodeOptimizations.synthesizeThrowIncompatibleClassChangeErrorMethod(
+ appView, context, methodProcessingId);
+ throwMethod.optimize(methodProcessor);
+
+ InvokeStatic throwInvoke =
+ InvokeStatic.builder()
+ .setMethod(throwMethod.getMethod())
+ .setFreshOutValue(appView, code)
+ .setPosition(invoke)
+ .build();
+ instructions.previous();
+ instructions.add(throwInvoke);
+ instructions.next();
+ instructions.replaceCurrentInstructionWithThrow(
+ appView, code, blockIterator, throwInvoke.outValue(), blocksToRemove, affectedValues);
}
private void rewriteInvokeSuper(
@@ -470,7 +536,7 @@
DexMethod amendedMethod = amendDefaultMethod(context.getHolder(), invokedMethod);
instructions.replaceCurrentInstruction(
new InvokeStatic(
- defaultAsMethodOfCompanionClass(amendedMethod),
+ defaultAsMethodOfCompanionClass(amendedMethod, appView.dexItemFactory()),
invoke.outValue(),
invoke.arguments()));
} else {
@@ -484,7 +550,7 @@
if (holder.isLibraryClass() && holder.isInterface()) {
instructions.replaceCurrentInstruction(
new InvokeStatic(
- defaultAsMethodOfCompanionClass(target.getReference(), factory),
+ defaultAsMethodOfCompanionClass(target),
invoke.outValue(),
invoke.arguments()));
}
@@ -504,9 +570,7 @@
DexMethod retargetMethod =
options.desugaredLibraryConfiguration.retargetMethod(superTarget, appView);
if (retargetMethod == null) {
- DexMethod originalCompanionMethod =
- instanceAsMethodOfCompanionClass(
- superTarget.getReference(), DEFAULT_METHOD_PREFIX, factory);
+ DexMethod originalCompanionMethod = defaultAsMethodOfCompanionClass(superTarget);
DexMethod companionMethod =
factory.createMethod(
getCompanionClassType(emulatedItf),
@@ -892,12 +956,11 @@
// Represent a static interface method as a method of companion class.
final DexMethod staticAsMethodOfCompanionClass(DexClassAndMethod method) {
- return staticAsMethodOfCompanionClass(method.getReference());
- }
-
- final DexMethod staticAsMethodOfCompanionClass(DexMethod method) {
- // No changes for static methods.
- return factory.createMethod(getCompanionClassType(method.holder), method.proto, method.name);
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexType companionClassType = getCompanionClassType(method.getHolderType(), dexItemFactory);
+ DexMethod rewritten = method.getReference().withHolder(companionClassType, dexItemFactory);
+ recordCompanionClassReference(appView, method, rewritten);
+ return rewritten;
}
private static DexMethod instanceAsMethodOfCompanionClass(
@@ -930,12 +993,11 @@
return instanceAsMethodOfCompanionClass(method, DEFAULT_METHOD_PREFIX, factory);
}
- DexMethod defaultAsMethodOfCompanionClass(DexMethod method) {
- return defaultAsMethodOfCompanionClass(method, factory);
- }
-
- DexMethod defaultAsMethodOfCompanionClass(DexClassAndMethod method) {
- return defaultAsMethodOfCompanionClass(method.getReference(), factory);
+ final DexMethod defaultAsMethodOfCompanionClass(DexClassAndMethod method) {
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexMethod rewritten = defaultAsMethodOfCompanionClass(method.getReference(), dexItemFactory);
+ recordCompanionClassReference(appView, method, rewritten);
+ return rewritten;
}
// Represent a private instance interface method as a method of companion class.
@@ -944,8 +1006,57 @@
return instanceAsMethodOfCompanionClass(method, PRIVATE_METHOD_PREFIX, factory);
}
- DexMethod privateAsMethodOfCompanionClass(DexMethod method) {
- return privateAsMethodOfCompanionClass(method, factory);
+ private DexMethod privateAsMethodOfCompanionClass(DexClassAndMethod method) {
+ return privateAsMethodOfCompanionClass(method.getReference(), factory);
+ }
+
+ private static void recordCompanionClassReference(
+ AppView<?> appView, DexClassAndMethod method, DexMethod rewritten) {
+ // If the interface class is a program class, we shouldn't need to synthesize the companion
+ // class on the classpath.
+ if (method.getHolder().isProgramClass()) {
+ return;
+ }
+
+ // If the companion class does not exist, then synthesize it on the classpath.
+ DexClass companionClass = appView.definitionFor(rewritten.getHolderType());
+ if (companionClass == null) {
+ companionClass =
+ synthesizeEmptyCompanionClass(appView, rewritten.getHolderType(), method.getHolder());
+ }
+
+ // If the companion class is a classpath class, then synthesize the companion class method if it
+ // does not exist.
+ if (companionClass.isClasspathClass()) {
+ synthetizeCompanionClassMethodIfNotPresent(companionClass.asClasspathClass(), rewritten);
+ }
+ }
+
+ private static DexClasspathClass synthesizeEmptyCompanionClass(
+ AppView<?> appView, DexType type, DexClass context) {
+ return appView
+ .getSyntheticItems()
+ .createClasspathClass(
+ SyntheticKind.COMPANION_CLASS, type, context, appView.dexItemFactory());
+ }
+
+ private static void synthetizeCompanionClassMethodIfNotPresent(
+ DexClasspathClass companionClass, DexMethod method) {
+ MethodCollection methodCollection = companionClass.getMethodCollection();
+ synchronized (methodCollection) {
+ if (methodCollection.getMethod(method) == null) {
+ boolean d8R8Synthesized = true;
+ methodCollection.addDirectMethod(
+ new DexEncodedMethod(
+ method,
+ MethodAccessFlags.createPublicStaticSynthetic(),
+ MethodTypeSignature.noSignature(),
+ DexAnnotationSet.empty(),
+ ParameterAnnotationsList.empty(),
+ DexEncodedMethod.buildEmptyThrowingCfCode(method),
+ d8R8Synthesized));
+ }
+ }
}
private void renameEmulatedInterfaces() {
@@ -1128,6 +1239,7 @@
Builder<?> builder, Flavor flavour, Consumer<ProgramMethod> newSynthesizedMethodConsumer) {
ClassProcessor processor = new ClassProcessor(appView, this, newSynthesizedMethodConsumer);
// First we compute all desugaring *without* introducing forwarding methods.
+ assert appView.getSyntheticItems().verifyNonLegacySyntheticsAreCommitted();
for (DexProgramClass clazz : builder.getProgramClasses()) {
if (shouldProcess(clazz, flavour, false)) {
if (appView.isAlreadyLibraryDesugared(clazz)) {
@@ -1165,11 +1277,8 @@
|| missing.isD8R8SynthesizedClassType()
|| isCompanionClassType(missing)
|| emulatedInterfaces.containsValue(missing)
- || ObjectUtils.getBooleanOrElse(
- options.getProguardConfiguration(),
- configuration -> configuration.getDontWarnPatterns().matches(missing),
- false)
- || options.desugaredLibraryConfiguration.getCustomConversions().containsValue(missing);
+ || options.desugaredLibraryConfiguration.getCustomConversions().containsValue(missing)
+ || appView.getDontWarnConfiguration().matches(missing);
}
void warnMissingInterface(DexClass classToDesugar, DexClass implementing, DexType missing) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index c2db31a..e40251c 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -220,23 +220,28 @@
List<DexEncodedMethod> companionMethods,
InterfaceProcessorNestedGraphLens.Builder graphLensBuilder) {
List<DexEncodedMethod> newVirtualMethods = new ArrayList<>();
- for (DexEncodedMethod virtual : iface.virtualMethods()) {
+ for (ProgramMethod method : iface.virtualProgramMethods()) {
+ DexEncodedMethod virtual = method.getDefinition();
if (rewriter.isDefaultMethod(virtual)) {
if (!canMoveToCompanionClass(virtual)) {
- throw new CompilationError("One or more instruction is preventing default interface "
- + "method from being desugared: " + virtual.method.toSourceString(), iface.origin);
+ throw new CompilationError(
+ "One or more instruction is preventing default interface "
+ + "method from being desugared: "
+ + method.toSourceString(),
+ iface.origin);
}
// Create a new method in a companion class to represent default method implementation.
- DexMethod companionMethod = rewriter.defaultAsMethodOfCompanionClass(virtual.method);
+ DexMethod companionMethod = rewriter.defaultAsMethodOfCompanionClass(method);
Code code = virtual.getCode();
if (code == null) {
- throw new CompilationError("Code is missing for default "
- + "interface method: " + virtual.method.toSourceString(), iface.origin);
+ throw new CompilationError(
+ "Code is missing for default " + "interface method: " + method.toSourceString(),
+ iface.origin);
}
- MethodAccessFlags newFlags = virtual.accessFlags.copy();
+ MethodAccessFlags newFlags = method.getAccessFlags().copy();
newFlags.promoteToStatic();
DexEncodedMethod.setDebugInfoWithFakeThisParameter(
code, companionMethod.getArity(), appView);
@@ -252,7 +257,7 @@
implMethod.copyMetadata(virtual);
virtual.setDefaultInterfaceMethodImplementation(implMethod);
companionMethods.add(implMethod);
- graphLensBuilder.recordCodeMovedToCompanionClass(virtual.method, implMethod.method);
+ graphLensBuilder.recordCodeMovedToCompanionClass(method.getReference(), implMethod.method);
}
// Remove bridge methods.
@@ -272,12 +277,13 @@
List<DexEncodedMethod> companionMethods,
InterfaceProcessorNestedGraphLens.Builder graphLensBuilder) {
DexEncodedMethod clinit = null;
- for (DexEncodedMethod method : iface.directMethods()) {
- if (method.isClassInitializer()) {
- clinit = method;
+ for (ProgramMethod method : iface.directProgramMethods()) {
+ DexEncodedMethod definition = method.getDefinition();
+ if (definition.isClassInitializer()) {
+ clinit = definition;
continue;
}
- if (method.isInstanceInitializer()) {
+ if (definition.isInstanceInitializer()) {
assert false
: "Unexpected interface instance initializer: "
+ method.getReference().toSourceString();
@@ -291,24 +297,24 @@
}
DexMethod oldMethod = method.getReference();
- if (isStaticMethod(method)) {
+ if (isStaticMethod(definition)) {
assert originalFlags.isPrivate() || originalFlags.isPublic()
: "Static interface method "
+ method.toSourceString()
+ " is expected to "
+ "either be public or private in "
+ iface.origin;
- DexMethod companionMethod = rewriter.staticAsMethodOfCompanionClass(oldMethod);
+ DexMethod companionMethod = rewriter.staticAsMethodOfCompanionClass(method);
DexEncodedMethod implMethod =
new DexEncodedMethod(
companionMethod,
newFlags,
- method.getGenericSignature(),
- method.annotations(),
- method.parameterAnnotationsList,
- method.getCode(),
+ definition.getGenericSignature(),
+ definition.annotations(),
+ definition.parameterAnnotationsList,
+ definition.getCode(),
true);
- implMethod.copyMetadata(method);
+ implMethod.copyMetadata(definition);
companionMethods.add(implMethod);
graphLensBuilder.move(oldMethod, companionMethod);
continue;
@@ -318,9 +324,10 @@
newFlags.promoteToStatic();
- DexMethod companionMethod = rewriter.privateAsMethodOfCompanionClass(oldMethod);
+ DexMethod companionMethod =
+ rewriter.privateAsMethodOfCompanionClass(oldMethod, appView.dexItemFactory());
- Code code = method.getCode();
+ Code code = definition.getCode();
if (code == null) {
throw new CompilationError(
"Code is missing for private instance "
@@ -333,12 +340,12 @@
new DexEncodedMethod(
companionMethod,
newFlags,
- method.getGenericSignature(),
- method.annotations(),
- method.parameterAnnotationsList,
+ definition.getGenericSignature(),
+ definition.annotations(),
+ definition.parameterAnnotationsList,
code,
true);
- implMethod.copyMetadata(method);
+ implMethod.copyMetadata(definition);
companionMethods.add(implMethod);
graphLensBuilder.move(oldMethod, companionMethod);
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index a50581e..477d8d8 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -8,7 +8,6 @@
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -20,10 +19,8 @@
import com.android.tools.r8.graph.DexProto;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
import com.android.tools.r8.graph.DexValue.DexValueNull;
import com.android.tools.r8.graph.FieldAccessFlags;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature;
import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.MethodAccessFlags;
@@ -37,18 +34,11 @@
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
import com.android.tools.r8.ir.synthetic.SynthesizedCode;
-import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.android.tools.r8.synthesis.SyntheticProgramClassBuilder;
import com.android.tools.r8.utils.OptionalBool;
-import com.google.common.base.Suppliers;
-import com.google.common.primitives.Longs;
-import java.nio.ByteBuffer;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Supplier;
-import java.util.zip.CRC32;
/**
* Represents lambda class generated for a lambda descriptor in context of lambda instantiation
@@ -77,31 +67,27 @@
final DexMethod classConstructor;
public final DexField lambdaField;
public final Target target;
- public final AtomicBoolean addToMainDexList = new AtomicBoolean(false);
- private final Collection<DexProgramClass> synthesizedFrom = new ArrayList<>(1);
- private final Supplier<DexProgramClass> lazyDexClass =
- Suppliers.memoize(this::synthesizeLambdaClass); // NOTE: thread-safe.
+
+ // Considered final but is set after due to circularity in allocation.
+ private DexProgramClass clazz = null;
LambdaClass(
+ SyntheticProgramClassBuilder builder,
AppView<?> appView,
LambdaRewriter rewriter,
ProgramMethod accessedFrom,
- DexType lambdaClassType,
LambdaDescriptor descriptor) {
assert rewriter != null;
- assert lambdaClassType != null;
assert descriptor != null;
-
+ this.type = builder.getType();
this.appView = appView;
this.rewriter = rewriter;
- this.type = lambdaClassType;
this.descriptor = descriptor;
- DexItemFactory factory = appView.dexItemFactory();
+ DexItemFactory factory = builder.getFactory();
DexProto constructorProto = factory.createProto(
factory.voidType, descriptor.captures.values);
- this.constructor =
- factory.createMethod(lambdaClassType, constructorProto, factory.constructorMethodName);
+ this.constructor = factory.createMethod(type, constructorProto, factory.constructorMethodName);
this.target = createTarget(accessedFrom);
@@ -109,98 +95,32 @@
this.classConstructor =
!stateless
? null
- : factory.createMethod(
- lambdaClassType, constructorProto, factory.classConstructorMethodName);
+ : factory.createMethod(type, constructorProto, factory.classConstructorMethodName);
this.lambdaField =
- !stateless
- ? null
- : factory.createField(lambdaClassType, lambdaClassType, rewriter.instanceFieldName);
+ !stateless ? null : factory.createField(type, type, rewriter.instanceFieldName);
+
+ // Synthesize the program class one all fields are set.
+ synthesizeLambdaClass(builder);
}
- // Generate unique lambda class type for lambda descriptor and instantiation point context.
- public static DexType createLambdaClassType(
- AppView<?> appView, ProgramMethod accessedFrom, LambdaDescriptor match) {
- StringBuilder lambdaClassDescriptor = new StringBuilder("L");
-
- // We always create lambda class in the same package where it is referenced.
- String packageDescriptor = accessedFrom.getHolderType().getPackageDescriptor();
- if (!packageDescriptor.isEmpty()) {
- lambdaClassDescriptor.append(packageDescriptor).append('/');
- }
-
- // Lambda class name prefix
- lambdaClassDescriptor.append(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX);
-
- // If the lambda class should match 1:1 the class it is accessed from, we
- // just add the name of this type to make lambda class name unique.
- // It also helps link the class lambda originated from in some cases.
- if (match.delegatesToLambdaImplMethod() || match.needsAccessor(accessedFrom)) {
- lambdaClassDescriptor.append(accessedFrom.getHolderType().getName()).append('$');
- }
-
- // Add unique lambda descriptor id
- lambdaClassDescriptor.append(match.uniqueId).append(';');
- return appView.dexItemFactory().createType(lambdaClassDescriptor.toString());
- }
-
- public final DexProgramClass getOrCreateLambdaClass() {
- return lazyDexClass.get();
- }
-
- private DexProgramClass synthesizeLambdaClass() {
- DexMethod mainMethod =
- appView.dexItemFactory().createMethod(type, descriptor.erasedProto, descriptor.name);
-
- DexProgramClass clazz =
- new DexProgramClass(
- type,
- null,
- new SynthesizedOrigin("lambda desugaring", getClass()),
- // Make the synthesized class public, as it might end up being accessed from a different
- // classloader (package private access is not allowed across classloaders, b/72538146).
- ClassAccessFlags.fromDexAccessFlags(
- Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
- appView.dexItemFactory().objectType,
- buildInterfaces(),
- appView.dexItemFactory().createString("lambda"),
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- synthesizeStaticFields(),
- synthesizeInstanceFields(),
- synthesizeDirectMethods(),
- synthesizeVirtualMethods(mainMethod),
- appView.dexItemFactory().getSkipNameValidationForTesting(),
- LambdaClass::computeChecksumForSynthesizedClass);
- appView.appInfo().addSynthesizedClass(clazz, false);
-
- // The method addSynthesizedFrom() may be called concurrently. To avoid a Concurrent-
- // ModificationException we must use synchronization.
- synchronized (synthesizedFrom) {
- synthesizedFrom.forEach(clazz::addSynthesizedFrom);
- }
+ public final DexProgramClass getLambdaProgramClass() {
+ assert clazz != null;
return clazz;
}
- private static long computeChecksumForSynthesizedClass(DexProgramClass clazz) {
- // Checksum of synthesized classes are compute based off the depending input. This might
- // create false positives (ie: unchanged lambda class detected as changed even thought only
- // an unrelated part from a synthesizedFrom class is changed).
+ void setClass(DexProgramClass clazz) {
+ assert this.clazz == null;
+ assert clazz != null;
+ assert type == clazz.type;
+ this.clazz = clazz;
+ }
- // Ideally, we should use some hashcode of the dex program class that is deterministic across
- // compiles.
- Collection<DexProgramClass> synthesizedFrom = clazz.getSynthesizedFrom();
- ByteBuffer buffer = ByteBuffer.allocate(synthesizedFrom.size() * Longs.BYTES);
- for (DexProgramClass from : synthesizedFrom) {
- buffer.putLong(from.getChecksum());
- }
- CRC32 crc = new CRC32();
- byte[] array = buffer.array();
- crc.update(array, 0, array.length);
- return crc.getValue();
+ private void synthesizeLambdaClass(SyntheticProgramClassBuilder builder) {
+ builder.setInterfaces(descriptor.interfaces);
+ synthesizeStaticFields(builder);
+ synthesizeInstanceFields(builder);
+ synthesizeDirectMethods(builder);
+ synthesizeVirtualMethods(builder);
}
final DexField getCaptureField(int index) {
@@ -216,24 +136,15 @@
return descriptor.isStateless();
}
- void addSynthesizedFrom(DexProgramClass clazz) {
- assert clazz != null;
- synchronized (synthesizedFrom) {
- if (synthesizedFrom.add(clazz)) {
- // The lambda class may already have been synthesized, and we therefore need to update the
- // synthesized lambda class as well.
- getOrCreateLambdaClass().addSynthesizedFrom(clazz);
- }
- }
- }
-
// Synthesize virtual methods.
- private DexEncodedMethod[] synthesizeVirtualMethods(DexMethod mainMethod) {
- DexEncodedMethod[] methods = new DexEncodedMethod[1 + descriptor.bridges.size()];
- int index = 0;
+ private void synthesizeVirtualMethods(SyntheticProgramClassBuilder builder) {
+ DexMethod mainMethod =
+ appView.dexItemFactory().createMethod(type, descriptor.erasedProto, descriptor.name);
+
+ List<DexEncodedMethod> methods = new ArrayList<>(1 + descriptor.bridges.size());
// Synthesize main method.
- methods[index++] =
+ methods.add(
new DexEncodedMethod(
mainMethod,
MethodAccessFlags.fromSharedAccessFlags(
@@ -242,13 +153,13 @@
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
LambdaMainMethodSourceCode.build(this, mainMethod),
- true);
+ true));
// Synthesize bridge methods.
for (DexProto bridgeProto : descriptor.bridges) {
DexMethod bridgeMethod =
appView.dexItemFactory().createMethod(type, bridgeProto, descriptor.name);
- methods[index++] =
+ methods.add(
new DexEncodedMethod(
bridgeMethod,
MethodAccessFlags.fromSharedAccessFlags(
@@ -261,18 +172,18 @@
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
LambdaBridgeMethodSourceCode.build(this, bridgeMethod, mainMethod),
- true);
+ true));
}
- return methods;
+ builder.setVirtualMethods(methods);
}
// Synthesize direct methods.
- private DexEncodedMethod[] synthesizeDirectMethods() {
+ private void synthesizeDirectMethods(SyntheticProgramClassBuilder builder) {
boolean stateless = isStateless();
- DexEncodedMethod[] methods = new DexEncodedMethod[stateless ? 2 : 1];
+ List<DexEncodedMethod> methods = new ArrayList<>(stateless ? 2 : 1);
// Constructor.
- methods[0] =
+ methods.add(
new DexEncodedMethod(
constructor,
MethodAccessFlags.fromSharedAccessFlags(
@@ -283,11 +194,11 @@
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
LambdaConstructorSourceCode.build(this),
- true);
+ true));
// Class constructor for stateless lambda classes.
if (stateless) {
- methods[1] =
+ methods.add(
new DexEncodedMethod(
classConstructor,
MethodAccessFlags.fromSharedAccessFlags(
@@ -296,61 +207,50 @@
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
LambdaClassConstructorSourceCode.build(this),
- true);
- feedback.classInitializerMayBePostponed(methods[1]);
+ true));
+ feedback.classInitializerMayBePostponed(methods.get(1));
}
- return methods;
+ builder.setDirectMethods(methods);
}
// Synthesize instance fields to represent captured values.
- private DexEncodedField[] synthesizeInstanceFields() {
+ private void synthesizeInstanceFields(SyntheticProgramClassBuilder builder) {
DexType[] fieldTypes = descriptor.captures.values;
int fieldCount = fieldTypes.length;
- DexEncodedField[] fields = new DexEncodedField[fieldCount];
+ List<DexEncodedField> fields = new ArrayList<>(fieldCount);
for (int i = 0; i < fieldCount; i++) {
FieldAccessFlags accessFlags =
FieldAccessFlags.fromSharedAccessFlags(
Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC);
- fields[i] =
+ fields.add(
new DexEncodedField(
getCaptureField(i),
accessFlags,
FieldTypeSignature.noSignature(),
DexAnnotationSet.empty(),
- null);
+ null));
}
- return fields;
+ builder.setInstanceFields(fields);
}
// Synthesize static fields to represent singleton instance.
- private DexEncodedField[] synthesizeStaticFields() {
- if (!isStateless()) {
- return DexEncodedField.EMPTY_ARRAY;
+ private void synthesizeStaticFields(SyntheticProgramClassBuilder builder) {
+ if (isStateless()) {
+ // Create instance field for stateless lambda.
+ assert this.lambdaField != null;
+ builder.setStaticFields(
+ Collections.singletonList(
+ new DexEncodedField(
+ this.lambdaField,
+ FieldAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC
+ | Constants.ACC_FINAL
+ | Constants.ACC_SYNTHETIC
+ | Constants.ACC_STATIC),
+ FieldTypeSignature.noSignature(),
+ DexAnnotationSet.empty(),
+ DexValueNull.NULL)));
}
-
- // Create instance field for stateless lambda.
- assert this.lambdaField != null;
- DexEncodedField[] fields = new DexEncodedField[1];
- fields[0] =
- new DexEncodedField(
- this.lambdaField,
- FieldAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC
- | Constants.ACC_FINAL
- | Constants.ACC_SYNTHETIC
- | Constants.ACC_STATIC),
- FieldTypeSignature.noSignature(),
- DexAnnotationSet.empty(),
- DexValueNull.NULL);
- return fields;
- }
-
- // Build a list of implemented interfaces.
- private DexTypeList buildInterfaces() {
- List<DexType> interfaces = descriptor.interfaces;
- return interfaces.isEmpty()
- ? DexTypeList.empty()
- : new DexTypeList(interfaces.toArray(DexType.EMPTY_ARRAY));
}
// Creates a delegation target for this particular lambda class. Note that we
@@ -643,11 +543,15 @@
newMethod.getCode(), callTarget.getArity(), appView);
return newMethod;
});
-
- assert replacement != null
- : "Unexpected failure to find direct lambda target for: " + implMethod.qualifiedName();
-
- return new ProgramMethod(implMethodHolder, replacement);
+ if (replacement != null) {
+ return new ProgramMethod(implMethodHolder, replacement);
+ }
+ // The method might already have been moved by another invoke-dynamic targeting it.
+ // If so, it must be defined on the holder.
+ ProgramMethod modified = implMethodHolder.lookupProgramMethod(callTarget);
+ assert modified != null;
+ assert modified.getDefinition().isNonPrivateVirtualMethod();
+ return modified;
}
}
@@ -713,11 +617,27 @@
rewriter.forcefullyMoveMethod(encodedMethod.method, callTarget);
return newMethod;
});
- return new ProgramMethod(implMethodHolder, replacement);
+ if (replacement != null) {
+ return new ProgramMethod(implMethodHolder, replacement);
+ }
+ // The method might already have been moved by another invoke-dynamic targeting it.
+ // If so, it must be defined on the holder.
+ ProgramMethod modified = implMethodHolder.lookupProgramMethod(callTarget);
+ assert modified != null;
+ assert modified.getDefinition().isNonPrivateVirtualMethod();
+ return modified;
}
private ProgramMethod createSyntheticAccessor(
DexMethod implMethod, DexProgramClass implMethodHolder) {
+ // The accessor might already have been created by another invoke-dynamic targeting it.
+ ProgramMethod existing = implMethodHolder.lookupProgramMethod(callTarget);
+ if (existing != null) {
+ assert existing.getAccessFlags().isSynthetic();
+ assert existing.getAccessFlags().isPublic();
+ assert existing.getDefinition().isVirtualMethod();
+ return existing;
+ }
MethodAccessFlags accessorFlags =
MethodAccessFlags.fromSharedAccessFlags(
Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC, false);
@@ -762,6 +682,15 @@
DexProgramClass accessorClass = appView.definitionForProgramType(callTarget.holder);
assert accessorClass != null;
+ // The accessor might already have been created by another invoke-dynamic targeting it.
+ ProgramMethod existing = accessorClass.lookupProgramMethod(callTarget);
+ if (existing != null) {
+ assert existing.getAccessFlags().isSynthetic();
+ assert existing.getAccessFlags().isPublic();
+ assert existing.getAccessFlags().isStatic();
+ return existing;
+ }
+
// Always make the method public to provide access when r8 minification is allowed to move
// the lambda class accessing this method to another package (-allowaccessmodification).
MethodAccessFlags accessorFlags =
@@ -779,11 +708,7 @@
AccessorMethodSourceCode.build(LambdaClass.this, callTarget),
true);
- // We may arrive here concurrently so we need must update the methods of the class atomically.
- synchronized (accessorClass) {
- accessorClass.addDirectMethod(accessorEncodedMethod);
- }
-
+ accessorClass.addDirectMethod(accessorEncodedMethod);
return new ProgramMethod(accessorClass, accessorEncodedMethod);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index f464fdd..165cb52 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -16,7 +16,6 @@
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
-import com.android.tools.r8.graph.DexApplication.Builder;
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
@@ -28,32 +27,25 @@
import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.Nullability;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeCustom;
-import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.NewInstance;
-import com.android.tools.r8.ir.code.StaticGet;
-import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.code.ValueType;
import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.synthesis.SyntheticNaming;
+import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
import com.android.tools.r8.utils.collections.BidirectionalOneToOneMap;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
+import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.IdentityHashMap;
+import java.util.Collections;
import java.util.List;
-import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.function.Function;
@@ -69,7 +61,6 @@
public class LambdaRewriter {
// Public for testing.
- public static final String LAMBDA_CLASS_NAME_PREFIX = "-$$Lambda$";
public static final String LAMBDA_GROUP_CLASS_NAME_PREFIX = "-$$LambdaGroup$";
static final String EXPECTED_LAMBDA_METHOD_PREFIX = "lambda$";
public static final String LAMBDA_INSTANCE_FIELD_NAME = "INSTANCE";
@@ -81,16 +72,11 @@
private final LambdaRewriterLens.Builder lensBuilder = LambdaRewriterLens.builder();
private final Set<DexMethod> forcefullyMovedMethods = Sets.newIdentityHashSet();
- // Maps call sites seen so far to inferred lambda descriptor. It is intended
- // to help avoid re-matching call sites we already seen. Note that same call
- // site may match one or several lambda classes.
- //
- // NOTE: synchronize concurrent access on `knownCallSites`.
- private final Map<DexCallSite, LambdaDescriptor> knownCallSites = new IdentityHashMap<>();
- // Maps lambda class type into lambda class representation. Since lambda class
- // type uniquely defines lambda class, effectively canonicalizes lambda classes.
+ // Maps lambda class type into lambda class representation.
// NOTE: synchronize concurrent access on `knownLambdaClasses`.
- private final Map<DexType, LambdaClass> knownLambdaClasses = new IdentityHashMap<>();
+ private final List<LambdaClass> knownLambdaClasses = new ArrayList<>();
+
+ private final Map<DexMethod, Integer> methodIds = new ConcurrentHashMap<>();
public LambdaRewriter(AppView<?> appView) {
this.appView = appView;
@@ -138,7 +124,7 @@
if (descriptor == null) {
return null;
}
- return getOrCreateLambdaClass(descriptor, method);
+ return createLambdaClass(descriptor, method);
});
}
@@ -209,16 +195,10 @@
}
/** Generates lambda classes and adds them to the builder. */
- public void finalizeLambdaDesugaringForD8(
- Builder<?> builder, IRConverter converter, ExecutorService executorService)
+ public void finalizeLambdaDesugaringForD8(IRConverter converter, ExecutorService executorService)
throws ExecutionException {
synthesizeAccessibilityBridgesForLambdaClassesD8(
- knownLambdaClasses.values(), converter, executorService);
- for (LambdaClass lambdaClass : knownLambdaClasses.values()) {
- DexProgramClass synthesizedClass = lambdaClass.getOrCreateLambdaClass();
- appView.appInfo().addSynthesizedClass(synthesizedClass, lambdaClass.addToMainDexList.get());
- builder.addSynthesizedClass(synthesizedClass);
- }
+ knownLambdaClasses, converter, executorService);
fixup();
optimizeSynthesizedClasses(converter, executorService);
}
@@ -226,183 +206,44 @@
private void optimizeSynthesizedClasses(IRConverter converter, ExecutorService executorService)
throws ExecutionException {
converter.optimizeSynthesizedClasses(
- knownLambdaClasses.values().stream()
- .map(LambdaClass::getOrCreateLambdaClass)
+ knownLambdaClasses.stream()
+ .map(LambdaClass::getLambdaProgramClass)
.collect(ImmutableSet.toImmutableSet()),
executorService);
}
- // Matches invoke-custom instruction operands to infer lambda descriptor
- // corresponding to this lambda invocation point.
- //
- // Returns the lambda descriptor or `MATCH_FAILED`.
- private LambdaDescriptor inferLambdaDescriptor(DexCallSite callSite, ProgramMethod context) {
- // We check the map before and after inferring lambda descriptor to minimize time
- // spent in synchronized block. As a result we may throw away calculated descriptor
- // in rare case when another thread has same call site processed concurrently,
- // but this is a low price to pay comparing to making whole method synchronous.
- LambdaDescriptor descriptor = getKnown(knownCallSites, callSite);
- return descriptor != null
- ? descriptor
- : putIfAbsent(
- knownCallSites,
- callSite,
- LambdaDescriptor.infer(callSite, appView.appInfoForDesugaring(), context));
- }
-
- // Returns a lambda class corresponding to the lambda descriptor and context,
- // creates the class if it does not yet exist.
- public LambdaClass getOrCreateLambdaClass(
- LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
- DexType lambdaClassType = LambdaClass.createLambdaClassType(appView, accessedFrom, descriptor);
- // We check the map twice to to minimize time spent in synchronized block.
- LambdaClass lambdaClass = getKnown(knownLambdaClasses, lambdaClassType);
- if (lambdaClass == null) {
- lambdaClass =
- putIfAbsent(
- knownLambdaClasses,
- lambdaClassType,
- new LambdaClass(appView, this, accessedFrom, lambdaClassType, descriptor));
- if (appView.options().isDesugaredLibraryCompilation()) {
- DexType rewrittenType =
- appView.rewritePrefix.rewrittenType(accessedFrom.getHolderType(), appView);
- if (rewrittenType == null) {
- rewrittenType =
- appView
- .options()
- .desugaredLibraryConfiguration
- .getEmulateLibraryInterface()
- .get(accessedFrom.getHolderType());
- }
- if (rewrittenType != null) {
- addRewritingPrefix(accessedFrom, rewrittenType, lambdaClassType);
- }
- }
- }
- lambdaClass.addSynthesizedFrom(accessedFrom.getHolder());
- if (appView.appInfo().getMainDexClasses().contains(accessedFrom.getHolder())) {
- lambdaClass.addToMainDexList.set(true);
+ // Creates a lambda class corresponding to the lambda descriptor and context.
+ public LambdaClass createLambdaClass(LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
+ int nextId =
+ methodIds.compute(
+ accessedFrom.getReference(), (method, value) -> value == null ? 0 : value + 1);
+ Box<LambdaClass> box = new Box<>();
+ DexProgramClass clazz =
+ appView
+ .getSyntheticItems()
+ .createClass(
+ SyntheticNaming.SyntheticKind.LAMBDA,
+ accessedFrom.getHolder(),
+ appView.dexItemFactory(),
+ // TODO(b/172194101): Make this part of a unique context construction.
+ () -> {
+ Hasher hasher = Hashing.sha256().newHasher();
+ accessedFrom.getReference().hash(hasher);
+ return "$" + hasher.hash().toString() + "$" + nextId;
+ },
+ builder ->
+ box.set(new LambdaClass(builder, appView, this, accessedFrom, descriptor)));
+ // Immediately set the actual program class on the lambda.
+ LambdaClass lambdaClass = box.get();
+ lambdaClass.setClass(clazz);
+ synchronized (knownLambdaClasses) {
+ knownLambdaClasses.add(lambdaClass);
}
return lambdaClass;
}
- private LambdaClass getKnownLambdaClass(LambdaDescriptor descriptor, ProgramMethod accessedFrom) {
- DexType lambdaClassType = LambdaClass.createLambdaClassType(appView, accessedFrom, descriptor);
- return getKnown(knownLambdaClasses, lambdaClassType);
- }
-
- private void addRewritingPrefix(
- ProgramMethod context, DexType rewritten, DexType lambdaClassType) {
- String javaName = lambdaClassType.toString();
- String typeString = context.getHolderType().toString();
- String actualPrefix = typeString.substring(0, typeString.lastIndexOf('.'));
- String rewrittenString = rewritten.toString();
- String actualRewrittenPrefix = rewrittenString.substring(0, rewrittenString.lastIndexOf('.'));
- assert javaName.startsWith(actualPrefix);
- appView.rewritePrefix.rewriteType(
- lambdaClassType,
- appView
- .dexItemFactory()
- .createType(
- DescriptorUtils.javaTypeToDescriptor(
- actualRewrittenPrefix + javaName.substring(actualPrefix.length()))));
- }
-
- private static <K, V> V getKnown(Map<K, V> map, K key) {
- synchronized (map) {
- return map.get(key);
- }
- }
-
- private static <K, V> V putIfAbsent(Map<K, V> map, K key, V value) {
- synchronized (map) {
- V known = map.get(key);
- if (known != null) {
- return known;
- }
- map.put(key, value);
- return value;
- }
- }
-
- // Patches invoke-custom instruction to create or get an instance
- // of the generated lambda class.
- private void patchInstruction(
- InvokeCustom invoke,
- LambdaClass lambdaClass,
- IRCode code,
- ListIterator<BasicBlock> blocks,
- InstructionListIterator instructions,
- Set<Value> affectedValues) {
- assert lambdaClass != null;
- assert instructions != null;
-
- // The value representing new lambda instance: we reuse the
- // value from the original invoke-custom instruction, and thus
- // all its usages.
- Value lambdaInstanceValue = invoke.outValue();
- if (lambdaInstanceValue == null) {
- // The out value might be empty in case it was optimized out.
- lambdaInstanceValue =
- code.createValue(
- TypeElement.fromDexType(lambdaClass.type, Nullability.maybeNull(), appView));
- } else {
- affectedValues.add(lambdaInstanceValue);
- }
-
- // For stateless lambdas we replace InvokeCustom instruction with StaticGet
- // reading the value of INSTANCE field created for singleton lambda class.
- if (lambdaClass.isStateless()) {
- instructions.replaceCurrentInstruction(
- new StaticGet(lambdaInstanceValue, lambdaClass.lambdaField));
- // Note that since we replace one throwing operation with another we don't need
- // to have any special handling for catch handlers.
- return;
- }
-
- // For stateful lambdas we always create a new instance since we need to pass
- // captured values to the constructor.
- //
- // We replace InvokeCustom instruction with a new NewInstance instruction
- // instantiating lambda followed by InvokeDirect instruction calling a
- // constructor on it.
- //
- // original:
- // Invoke-Custom rResult <- { rArg0, rArg1, ... }; call site: ...
- //
- // result:
- // NewInstance rResult <- LambdaClass
- // Invoke-Direct { rResult, rArg0, rArg1, ... }; method: void LambdaClass.<init>(...)
- lambdaInstanceValue.setType(
- lambdaInstanceValue.getType().asReferenceType().asDefinitelyNotNull());
- NewInstance newInstance = new NewInstance(lambdaClass.type, lambdaInstanceValue);
- instructions.replaceCurrentInstruction(newInstance);
-
- List<Value> arguments = new ArrayList<>();
- arguments.add(lambdaInstanceValue);
- arguments.addAll(invoke.arguments()); // Optional captures.
- InvokeDirect constructorCall =
- new InvokeDirect(lambdaClass.constructor, null /* no return value */, arguments);
- instructions.add(constructorCall);
- constructorCall.setPosition(newInstance.getPosition());
-
- // If we don't have catch handlers we are done.
- if (!constructorCall.getBlock().hasCatchHandlers()) {
- return;
- }
-
- // Move the iterator back to position it between the two instructions, split
- // the block between the two instructions, and copy the catch handlers.
- instructions.previous();
- assert instructions.peekNext().isInvokeDirect();
- BasicBlock currentBlock = newInstance.getBlock();
- BasicBlock nextBlock = instructions.split(code, blocks);
- assert !instructions.hasNext();
- nextBlock.copyCatchHandlers(code, blocks, currentBlock, appView.options());
- }
-
- public Map<DexType, LambdaClass> getKnownLambdaClasses() {
- return knownLambdaClasses;
+ public Collection<LambdaClass> getKnownLambdaClasses() {
+ return Collections.unmodifiableList(knownLambdaClasses);
}
public NestedGraphLens fixup() {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java
deleted file mode 100644
index eb42231..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java
+++ /dev/null
@@ -1,529 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-
-import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.ClasspathMethod;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClassAndMethod;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.NestMemberClassAttribute;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.origin.SynthesizedOrigin;
-import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.Pair;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-
-// NestBasedAccessDesugaring contains common code between the two subclasses
-// which are specialized for d8 and r8
-public abstract class NestBasedAccessDesugaring {
-
- // Short names to avoid creating long strings
- public static final String NEST_ACCESS_NAME_PREFIX = "-$$Nest$";
- private static final String NEST_ACCESS_METHOD_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "m";
- private static final String NEST_ACCESS_STATIC_METHOD_NAME_PREFIX =
- NEST_ACCESS_NAME_PREFIX + "sm";
- private static final String NEST_ACCESS_FIELD_GET_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "fget";
- private static final String NEST_ACCESS_STATIC_GET_FIELD_NAME_PREFIX =
- NEST_ACCESS_NAME_PREFIX + "sfget";
- private static final String NEST_ACCESS_FIELD_PUT_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "fput";
- private static final String NEST_ACCESS_STATIC_PUT_FIELD_NAME_PREFIX =
- NEST_ACCESS_NAME_PREFIX + "sfput";
- public static final String NEST_CONSTRUCTOR_NAME = NEST_ACCESS_NAME_PREFIX + "Constructor";
-
- protected final AppView<?> appView;
- // Following maps are there to avoid creating the bridges multiple times
- // and remember the bridges to add once the nests are processed.
- final Map<DexMethod, ProgramMethod> bridges = new ConcurrentHashMap<>();
- final Map<DexField, ProgramMethod> getFieldBridges = new ConcurrentHashMap<>();
- final Map<DexField, ProgramMethod> putFieldBridges = new ConcurrentHashMap<>();
- // Common single empty class for nest based private constructors
- private final DexProgramClass nestConstructor;
- private boolean nestConstructorUsed = false;
-
- NestBasedAccessDesugaring(AppView<?> appView) {
- this.appView = appView;
- this.nestConstructor = createNestAccessConstructor();
- }
-
- DexType getNestConstructorType() {
- assert nestConstructor != null;
- return nestConstructor.type;
- }
-
- abstract void reportMissingNestHost(DexClass clazz);
-
- abstract void reportIncompleteNest(List<DexType> nest);
-
- DexClass definitionFor(DexType type) {
- return appView.definitionFor(appView.graphLens().lookupType(type));
- }
-
- private DexEncodedMethod lookupOnHolder(
- DexMethod method, DexClassAndMethod context, Invoke.Type invokeType) {
- DexMethod rewritten =
- appView.graphLens().lookupMethod(method, context.getReference(), invokeType).getReference();
- return rewritten.lookupOnClass(appView.definitionForHolder(rewritten));
- }
-
- private DexEncodedField lookupOnHolder(DexField field) {
- DexField rewritten = appView.graphLens().lookupField(field);
- return rewritten.lookupOnClass(appView.definitionForHolder(rewritten));
- }
-
- // Extract the list of types in the programClass' nest, of host hostClass
- private Pair<DexClass, List<DexType>> extractNest(DexClass clazz) {
- assert clazz != null;
- DexClass hostClass = clazz.isNestHost() ? clazz : definitionFor(clazz.getNestHost());
- if (hostClass == null) {
- reportMissingNestHost(clazz);
- // Missing nest host means the class is considered as not being part of a nest.
- clazz.clearNestHost();
- return null;
- }
- List<DexType> classesInNest =
- new ArrayList<>(hostClass.getNestMembersClassAttributes().size() + 1);
- for (NestMemberClassAttribute nestmate : hostClass.getNestMembersClassAttributes()) {
- classesInNest.add(nestmate.getNestMember());
- }
- classesInNest.add(hostClass.type);
- return new Pair<>(hostClass, classesInNest);
- }
-
- Future<?> asyncProcessNest(DexProgramClass clazz, ExecutorService executorService) {
- return executorService.submit(
- () -> {
- Pair<DexClass, List<DexType>> nest = extractNest(clazz);
- // Nest is null when nest host is missing, we do nothing in this case.
- if (nest != null) {
- processNest(nest.getFirst(), nest.getSecond());
- }
- return null; // we want a Callable not a Runnable to be able to throw
- });
- }
-
- private void processNest(DexClass host, List<DexType> nest) {
- boolean reported = false;
- for (DexType type : nest) {
- DexClass clazz = definitionFor(type);
- if (clazz == null) {
- if (!reported) {
- reportIncompleteNest(nest);
- reported = true;
- }
- } else {
- reportDesugarDependencies(host, clazz);
- if (shouldProcessClassInNest(clazz, nest)) {
- for (DexEncodedMethod definition : clazz.methods()) {
- if (clazz.isProgramClass()) {
- ProgramMethod method = new ProgramMethod(clazz.asProgramClass(), definition);
- method.registerCodeReferences(new NestBasedAccessDesugaringUseRegistry(method));
- } else if (clazz.isClasspathClass()) {
- ClasspathMethod method = new ClasspathMethod(clazz.asClasspathClass(), definition);
- method.registerCodeReferencesForDesugaring(
- new NestBasedAccessDesugaringUseRegistry(method));
- } else {
- assert false;
- }
- }
- }
- }
- }
- }
-
- private void reportDesugarDependencies(DexClass host, DexClass clazz) {
- if (host == clazz) {
- return;
- }
- if (host.isProgramClass()) {
- InterfaceMethodRewriter.reportDependencyEdge(host.asProgramClass(), clazz, appView.options());
- }
- if (clazz.isProgramClass()) {
- InterfaceMethodRewriter.reportDependencyEdge(clazz.asProgramClass(), host, appView.options());
- }
- }
-
- protected abstract boolean shouldProcessClassInNest(DexClass clazz, List<DexType> nest);
-
- private DexProgramClass createNestAccessConstructor() {
- // TODO(b/176900254): The class generated should be in a package that has lower change of
- // collisions (and perhaps be unique by some hash from the nest).
- return new DexProgramClass(
- appView.dexItemFactory().nestConstructorType,
- null,
- new SynthesizedOrigin("Nest based access desugaring", getClass()),
- // Make the synthesized class public since shared in the whole program.
- ClassAccessFlags.fromDexAccessFlags(
- Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
- appView.dexItemFactory().objectType,
- DexTypeList.empty(),
- appView.dexItemFactory().createString("nest"),
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- appView.dexItemFactory().getSkipNameValidationForTesting(),
- DexProgramClass::checksumFromType);
- }
-
- void synthesizeNestConstructor(DexApplication.Builder<?> builder) {
- if (nestConstructorUsed) {
- appView.appInfo().addSynthesizedClass(nestConstructor, true);
- builder.addSynthesizedClass(nestConstructor);
- }
- }
-
- private DexString computeMethodBridgeName(DexEncodedMethod method) {
- String methodName = method.method.name.toString();
- String fullName;
- if (method.isStatic()) {
- fullName = NEST_ACCESS_STATIC_METHOD_NAME_PREFIX + methodName;
- } else {
- fullName = NEST_ACCESS_METHOD_NAME_PREFIX + methodName;
- }
- return appView.dexItemFactory().createString(fullName);
- }
-
- private DexString computeFieldBridgeName(DexEncodedField field, boolean isGet) {
- String fieldName = field.field.name.toString();
- String fullName;
- if (isGet && !field.isStatic()) {
- fullName = NEST_ACCESS_FIELD_GET_NAME_PREFIX + fieldName;
- } else if (isGet) {
- fullName = NEST_ACCESS_STATIC_GET_FIELD_NAME_PREFIX + fieldName;
- } else if (!field.isStatic()) {
- fullName = NEST_ACCESS_FIELD_PUT_NAME_PREFIX + fieldName;
- } else {
- fullName = NEST_ACCESS_STATIC_PUT_FIELD_NAME_PREFIX + fieldName;
- }
- return appView.dexItemFactory().createString(fullName);
- }
-
- private DexMethod computeMethodBridge(DexEncodedMethod encodedMethod) {
- DexMethod method = encodedMethod.method;
- DexProto proto =
- encodedMethod.accessFlags.isStatic()
- ? method.proto
- : appView.dexItemFactory().prependHolderToProto(method);
- return appView
- .dexItemFactory()
- .createMethod(method.holder, proto, computeMethodBridgeName(encodedMethod));
- }
-
- private DexMethod computeInitializerBridge(DexMethod method) {
- DexProto newProto =
- appView.dexItemFactory().appendTypeToProto(method.proto, nestConstructor.type);
- return appView.dexItemFactory().createMethod(method.holder, newProto, method.name);
- }
-
- private DexMethod computeFieldBridge(DexEncodedField field, boolean isGet) {
- DexType holderType = field.getHolderType();
- DexType fieldType = field.field.type;
- int bridgeParameterCount =
- BooleanUtils.intValue(!field.isStatic()) + BooleanUtils.intValue(!isGet);
- DexType[] parameters = new DexType[bridgeParameterCount];
- if (!isGet) {
- parameters[parameters.length - 1] = fieldType;
- }
- if (!field.isStatic()) {
- parameters[0] = holderType;
- }
- DexType returnType = isGet ? fieldType : appView.dexItemFactory().voidType;
- DexProto proto = appView.dexItemFactory().createProto(returnType, parameters);
- return appView
- .dexItemFactory()
- .createMethod(holderType, proto, computeFieldBridgeName(field, isGet));
- }
-
- boolean invokeRequiresRewriting(DexEncodedMethod method, DexClassAndMethod context) {
- assert method != null;
- // Rewrite only when targeting other nest members private fields.
- if (!method.accessFlags.isPrivate() || method.getHolderType() == context.getHolderType()) {
- return false;
- }
- DexClass methodHolder = definitionFor(method.getHolderType());
- assert methodHolder != null; // from encodedMethod
- return methodHolder.getNestHost() == context.getHolder().getNestHost();
- }
-
- boolean fieldAccessRequiresRewriting(DexEncodedField field, DexClassAndMethod context) {
- assert field != null;
- // Rewrite only when targeting other nest members private fields.
- if (!field.accessFlags.isPrivate() || field.getHolderType() == context.getHolderType()) {
- return false;
- }
- DexClass fieldHolder = definitionFor(field.getHolderType());
- assert fieldHolder != null; // from encodedField
- return fieldHolder.getNestHost() == context.getHolder().getNestHost();
- }
-
- private boolean holderRequiresBridge(DexClass holder) {
- // Bridges are added on program classes only.
- // Bridges on class paths are added in different compilation units.
- if (holder.isProgramClass()) {
- return false;
- } else if (holder.isClasspathClass()) {
- return true;
- }
- assert holder.isLibraryClass();
- Pair<DexClass, List<DexType>> nest = extractNest(holder);
- assert nest != null : "Should be a compilation error if missing nest host on library class.";
- reportIncompleteNest(nest.getSecond());
- throw new Unreachable(
- "Incomplete nest due to missing library class should raise a compilation error.");
- }
-
- DexMethod ensureFieldAccessBridge(DexEncodedField field, boolean isGet) {
- DexClass holder = definitionFor(field.getHolderType());
- assert holder != null;
- DexMethod bridgeMethod = computeFieldBridge(field, isGet);
- if (holderRequiresBridge(holder)) {
- return bridgeMethod;
- }
- assert holder.isProgramClass();
- // The map is used to avoid creating multiple times the bridge
- // and remembers the bridges to add.
- Map<DexField, ProgramMethod> fieldMap = isGet ? getFieldBridges : putFieldBridges;
- assert holder.isProgramClass();
- fieldMap.computeIfAbsent(
- field.field,
- k ->
- DexEncodedMethod.createFieldAccessorBridge(
- new DexFieldWithAccess(field, isGet), holder.asProgramClass(), bridgeMethod));
- return bridgeMethod;
- }
-
- DexMethod ensureInvokeBridge(DexEncodedMethod method) {
- // We add bridges only when targeting other nest members.
- DexClass holder = definitionFor(method.getHolderType());
- assert holder != null;
- DexMethod bridgeMethod;
- if (method.isInstanceInitializer()) {
- nestConstructorUsed = true;
- bridgeMethod = computeInitializerBridge(method.method);
- } else {
- bridgeMethod = computeMethodBridge(method);
- }
- if (holderRequiresBridge(holder)) {
- return bridgeMethod;
- }
- // The map is used to avoid creating multiple times the bridge
- // and remembers the bridges to add.
- assert holder.isProgramClass();
- bridges.computeIfAbsent(
- method.method,
- k ->
- method.isInstanceInitializer()
- ? method.toInitializerForwardingBridge(holder.asProgramClass(), bridgeMethod)
- : method.toStaticForwardingBridge(
- holder.asProgramClass(), computeMethodBridge(method)));
- return bridgeMethod;
- }
-
- protected class NestBasedAccessDesugaringUseRegistry extends UseRegistry {
-
- private final DexClassAndMethod context;
-
- NestBasedAccessDesugaringUseRegistry(DexClassAndMethod context) {
- super(appView.options().itemFactory);
- this.context = context;
- }
-
- private void registerInvoke(DexMethod method, Invoke.Type invokeType) {
- // Calls to non class type are not done through nest based access control.
- // Work-around for calls to enum.clone().
- if (!method.holder.isClassType()) {
- return;
- }
- DexEncodedMethod encodedMethod = lookupOnHolder(method, context, invokeType);
- if (encodedMethod != null && invokeRequiresRewriting(encodedMethod, context)) {
- ensureInvokeBridge(encodedMethod);
- }
- }
-
- private void registerFieldAccess(DexField field, boolean isGet) {
- // Since we only need to desugar accesses to private fields, and all accesses to private
- // fields must be accessing the private field directly on its holder, we can lookup the field
- // on the holder instead of resolving the field.
- DexEncodedField encodedField = lookupOnHolder(field);
- if (encodedField != null && fieldAccessRequiresRewriting(encodedField, context)) {
- ensureFieldAccessBridge(encodedField, isGet);
- }
- }
-
- @Override
- public void registerInitClass(DexType clazz) {
- // Nothing to do since we always use a public field for initializing the class.
- }
-
- @Override
- public void registerInvokeVirtual(DexMethod method) {
- // Calls to class nest mate private methods are targeted by invokeVirtual in jdk11.
- // The spec recommends to do so, but do not enforce it, hence invokeDirect is also registered.
- registerInvoke(method, Invoke.Type.VIRTUAL);
- }
-
- @Override
- public void registerInvokeDirect(DexMethod method) {
- registerInvoke(method, Invoke.Type.DIRECT);
- }
-
- @Override
- public void registerInvokeStatic(DexMethod method) {
- registerInvoke(method, Invoke.Type.STATIC);
- }
-
- @Override
- public void registerInvokeInterface(DexMethod method) {
- // Calls to interface nest mate private methods are targeted by invokeInterface in jdk11.
- // The spec recommends to do so, but do not enforce it, hence invokeDirect is also registered.
- registerInvoke(method, Invoke.Type.INTERFACE);
- }
-
- @Override
- public void registerInvokeSuper(DexMethod method) {
- registerInvoke(method, Invoke.Type.SUPER);
- }
-
- @Override
- public void registerInstanceFieldWrite(DexField field) {
- registerFieldAccess(field, false);
- }
-
- @Override
- public void registerInstanceFieldRead(DexField field) {
- registerFieldAccess(field, true);
- }
-
- @Override
- public void registerNewInstance(DexType type) {
- // Unrelated to access based control.
- // The <init> method has to be rewritten instead
- // and <init> is called through registerInvoke.
- }
-
- @Override
- public void registerStaticFieldRead(DexField field) {
- registerFieldAccess(field, true);
- }
-
- @Override
- public void registerStaticFieldWrite(DexField field) {
- registerFieldAccess(field, false);
- }
-
- @Override
- public void registerTypeReference(DexType type) {
- // Unrelated to access based control.
- }
-
- @Override
- public void registerInstanceOf(DexType type) {
- // Unrelated to access based control.
- }
- }
-
- public static final class DexFieldWithAccess {
-
- private final DexEncodedField field;
- private final boolean isGet;
-
- DexFieldWithAccess(DexEncodedField field, boolean isGet) {
- this.field = field;
- this.isGet = isGet;
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(field, isGet);
- }
-
- @Override
- public boolean equals(Object o) {
- if (o == null) {
- return false;
- }
- if (getClass() != o.getClass()) {
- return false;
- }
- DexFieldWithAccess other = (DexFieldWithAccess) o;
- return isGet == other.isGet && field == other.field;
- }
-
- public boolean isGet() {
- return isGet;
- }
-
- public boolean isStatic() {
- return field.accessFlags.isStatic();
- }
-
- public boolean isPut() {
- return !isGet();
- }
-
- public boolean isInstance() {
- return !isStatic();
- }
-
- public boolean isStaticGet() {
- return isStatic() && isGet();
- }
-
- public boolean isStaticPut() {
- return isStatic() && isPut();
- }
-
- public boolean isInstanceGet() {
- return isInstance() && isGet();
- }
-
- public boolean isInstancePut() {
- return isInstance() && isPut();
- }
-
- public DexType getType() {
- return field.field.type;
- }
-
- public DexType getHolder() {
- return field.getHolderType();
- }
-
- public DexField getField() {
- return field.field;
- }
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
deleted file mode 100644
index 12418b3..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLens;
-import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
-import com.android.tools.r8.graph.RewrittenPrototypeDescription;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.utils.collections.EmptyBidirectionalOneToOneMap;
-import com.google.common.collect.ImmutableMap;
-import java.util.IdentityHashMap;
-import java.util.Map;
-
-public class NestedPrivateMethodLens extends NestedGraphLens {
-
- // Map from nestHost to nest members including nest hosts
- private final DexType nestConstructorType;
- private final Map<DexField, DexMethod> getFieldMap;
- private final Map<DexField, DexMethod> putFieldMap;
-
- NestedPrivateMethodLens(
- AppView<?> appView,
- DexType nestConstructorType,
- Map<DexMethod, DexMethod> methodMap,
- Map<DexField, DexMethod> getFieldMap,
- Map<DexField, DexMethod> putFieldMap,
- GraphLens previousLens) {
- super(
- ImmutableMap.of(),
- methodMap,
- new EmptyBidirectionalOneToOneMap<>(),
- new EmptyBidirectionalOneToOneMap<>(),
- previousLens,
- appView.dexItemFactory());
- // No concurrent maps here, we do not want synchronization overhead.
- assert methodMap instanceof IdentityHashMap;
- assert getFieldMap instanceof IdentityHashMap;
- assert putFieldMap instanceof IdentityHashMap;
- this.nestConstructorType = nestConstructorType;
- this.getFieldMap = getFieldMap;
- this.putFieldMap = putFieldMap;
- }
-
- private DexMethod lookupFieldForMethod(
- DexField field, DexMethod context, Map<DexField, DexMethod> map) {
- assert context != null;
- DexMethod bridge = map.get(field);
- if (bridge != null && bridge.holder != context.holder) {
- return bridge;
- }
- return null;
- }
-
- @Override
- public DexMethod lookupGetFieldForMethod(DexField field, DexMethod context) {
- assert getPrevious().lookupGetFieldForMethod(field, context) == null;
- return lookupFieldForMethod(field, context, getFieldMap);
- }
-
- @Override
- public DexMethod lookupPutFieldForMethod(DexField field, DexMethod context) {
- assert getPrevious().lookupPutFieldForMethod(field, context) == null;
- return lookupFieldForMethod(field, context, putFieldMap);
- }
-
- @Override
- public boolean isContextFreeForMethods() {
- return methodMap.isEmpty();
- }
-
- @Override
- public boolean verifyIsContextFreeForMethod(DexMethod method) {
- assert !methodMap.containsKey(getPrevious().lookupMethod(method));
- return true;
- }
-
- // This is true because mappings specific to this class can be filled.
- @Override
- protected boolean isLegitimateToHaveEmptyMappings() {
- return true;
- }
-
- private boolean isConstructorBridge(DexMethod method) {
- DexType[] parameters = method.proto.parameters.values;
- if (parameters.length == 0) {
- return false;
- }
- DexType lastParameterType = parameters[parameters.length - 1];
- return lastParameterType == nestConstructorType;
- }
-
- @Override
- protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
- RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
- if (isConstructorBridge(method)) {
- // TODO (b/132767654): Try to write a test which breaks that assertion.
- assert prototypeChanges.isEmpty();
- // TODO(b/164901008): Fix when the number of arguments overflows.
- return RewrittenPrototypeDescription.none().withExtraUnusedNullParameter();
- }
- return prototypeChanges;
- }
-
- @Override
- public MethodLookupResult internalDescribeLookupMethod(
- MethodLookupResult previous, DexMethod context) {
- DexMethod bridge = methodMap.get(previous.getReference());
- if (bridge == null) {
- return previous;
- }
- assert context != null : "Guaranteed by isContextFreeForMethod";
- if (bridge.holder == context.holder) {
- return previous;
- }
- MethodLookupResult.Builder resultBuilder =
- MethodLookupResult.builder(this).setReference(bridge);
- if (isConstructorBridge(bridge)) {
- resultBuilder
- .setPrototypeChanges(
- internalDescribePrototypeChanges(previous.getPrototypeChanges(), bridge))
- .setType(Type.DIRECT);
- } else {
- resultBuilder.setPrototypeChanges(previous.getPrototypeChanges()).setType(Type.STATIC);
- }
- return resultBuilder.build();
- }
-
- public static Builder builder() {
- return new Builder();
- }
-
- public static class Builder extends NestedGraphLens.Builder {
-
- private Map<DexField, DexMethod> getFieldMap = new IdentityHashMap<>();
- private Map<DexField, DexMethod> putFieldMap = new IdentityHashMap<>();
-
- public void mapGetField(DexField from, DexMethod to) {
- getFieldMap.put(from, to);
- }
-
- public void mapPutField(DexField from, DexMethod to) {
- putFieldMap.put(from, to);
- }
-
- public NestedPrivateMethodLens build(AppView<?> appView, DexType nestConstructorType) {
- assert typeMap.isEmpty();
- assert fieldMap.isEmpty();
- if (getFieldMap.isEmpty() && methodMap.isEmpty() && putFieldMap.isEmpty()) {
- return null;
- }
- return new NestedPrivateMethodLens(
- appView, nestConstructorType, methodMap, getFieldMap, putFieldMap, appView.graphLens());
- }
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java
deleted file mode 100644
index e9ac116..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.utils.ThreadUtils;
-import com.google.common.collect.Sets;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-import java.util.function.BiConsumer;
-
-// Summary:
-// - Computes all the live nests reachable from Program Classes (Sequential), each time a
-// nest is computed, its processing starts concurrently.
-// - Add bridges to be processed by further passes and create the maps
-// for the lens (Sequential)
-public class R8NestBasedAccessDesugaring extends NestBasedAccessDesugaring {
-
- public R8NestBasedAccessDesugaring(AppView<?> appView) {
- super(appView);
- }
-
- public NestedPrivateMethodLens run(
- ExecutorService executorService, DexApplication.Builder<?> appBuilder)
- throws ExecutionException {
- assert !appView.options().canUseNestBasedAccess()
- || appView.options().testing.enableForceNestBasedAccessDesugaringForTest;
- computeAndProcessNestsConcurrently(executorService);
- NestedPrivateMethodLens.Builder lensBuilder = NestedPrivateMethodLens.builder();
- addDeferredBridgesAndMapMethods(lensBuilder);
- clearNestAttributes();
- synthesizeNestConstructor(appBuilder);
- return lensBuilder.build(appView, getNestConstructorType());
- }
-
- private void addDeferredBridgesAndMapMethods(NestedPrivateMethodLens.Builder lensBuilder) {
- // Here we add the bridges and we fill the lens map.
- addDeferredBridgesAndMapMethods(bridges, lensBuilder::map);
- addDeferredBridgesAndMapMethods(getFieldBridges, lensBuilder::mapGetField);
- addDeferredBridgesAndMapMethods(putFieldBridges, lensBuilder::mapPutField);
- }
-
- private <E> void addDeferredBridgesAndMapMethods(
- Map<E, ProgramMethod> bridges, BiConsumer<E, DexMethod> lensInserter) {
- for (Map.Entry<E, ProgramMethod> entry : bridges.entrySet()) {
- ProgramMethod method = entry.getValue();
- method.getHolder().addMethod(method.getDefinition());
- lensInserter.accept(entry.getKey(), method.getReference());
- }
- bridges.clear();
- }
-
- private void clearNestAttributes() {
- // Clearing nest attributes is required to allow class merging to be performed across nests
- // and to forbid other optimizations to introduce nest based accesses.
- for (DexClass clazz : appView.appInfo().classes()) {
- clazz.clearNestHost();
- clazz.getNestMembersClassAttributes().clear();
- }
- }
-
- private void computeAndProcessNestsConcurrently(ExecutorService executorService)
- throws ExecutionException {
- Set<DexType> nestHosts = Sets.newIdentityHashSet();
- ;
- List<Future<?>> futures = new ArrayList<>();
- // It is possible that a nest member is on the program path but its nest host
- // is only in the class path (or missing, raising an error).
- // Nests are therefore computed the first time a nest member is met, host or not.
- // The computedNestHosts list is there to avoid processing multiple times the same nest.
- for (DexProgramClass clazz : appView.appInfo().classes()) {
- if (clazz.isInANest()) {
- DexType hostType = clazz.getNestHost();
- if (!nestHosts.contains(hostType)) {
- nestHosts.add(hostType);
- futures.add(asyncProcessNest(clazz, executorService));
- }
- }
- }
- ThreadUtils.awaitFutures(futures);
- }
-
- // In R8, all classes are processed ahead of time.
- @Override
- protected boolean shouldProcessClassInNest(DexClass clazz, List<DexType> nest) {
- return true;
- }
-
- @Override
- void reportMissingNestHost(DexClass clazz) {
- if (appView.options().ignoreMissingClasses) {
- appView.options().nestDesugaringWarningMissingNestHost(clazz);
- } else {
- appView.options().errorMissingClassMissingNestHost(clazz);
- }
- }
-
- @Override
- void reportIncompleteNest(List<DexType> nest) {
- if (appView.options().ignoreMissingClasses) {
- appView.options().nestDesugaringWarningIncompleteNest(nest, appView);
- } else {
- appView.options().errorMissingClassIncompleteNest(nest, appView);
- }
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
index f7be74d..98acb2d 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
@@ -4,178 +4,137 @@
package com.android.tools.r8.ir.desugar;
-import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexApplication.Builder;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.MethodAccessFlags;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.desugar.backports.BackportedMethods;
-import com.android.tools.r8.origin.SynthesizedOrigin;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.InternalOptions;
-import com.google.common.collect.Sets;
-import java.util.Collections;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
+import com.android.tools.r8.utils.InternalOptions.DesugarState;
+import com.google.common.base.Suppliers;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.objectweb.asm.Opcodes;
-// Try with resources outlining processor. Handles $closeResource methods
-// synthesized by java 9 compiler.
+// Try with resources close-resource desugaring.
//
-// Works in two phases:
-// a. during method code processing finds all references to $closeResource(...) synthesized
-// by java compiler, and replaces them with references to a special utility class method.
-// b. after all methods are processed and if there was at least one method referencing
-// $closeResource(...), it synthesizes utility class with appropriate methods.
+// Rewrites $closeResource methods synthesized by java compilers to work on older DEX runtimes.
+// All invocations to $closeResource methods are rewritten to target a compiler generated version
+// that is correct on older DEX runtimes where not all types implement AutoClosable as expected.
//
// Note that we don't remove $closeResource(...) synthesized by java compiler, relying on
// tree shaking to remove them since now they should not be referenced.
-//
+// TODO(b/177401708): D8 does not tree shake so we should remove the now unused method.
public final class TwrCloseResourceRewriter {
- public static final String UTILITY_CLASS_NAME = "$r8$twr$utility";
- public static final String UTILITY_CLASS_DESCRIPTOR = "L$r8$twr$utility;";
-
private final AppView<?> appView;
- private final IRConverter converter;
+ private final DexProto twrCloseResourceProto;
+ private final List<ProgramMethod> synthesizedMethods = new ArrayList<>();
- private final DexMethod twrCloseResourceMethod;
-
- private final Set<DexProgramClass> referencingClasses = Sets.newConcurrentHashSet();
-
- public TwrCloseResourceRewriter(AppView<?> appView, IRConverter converter) {
- this.appView = appView;
- this.converter = converter;
-
- DexItemFactory dexItemFactory = appView.dexItemFactory();
- DexType twrUtilityClass = dexItemFactory.createType(UTILITY_CLASS_DESCRIPTOR);
- DexProto twrCloseResourceProto =
- dexItemFactory.createProto(
- dexItemFactory.voidType, dexItemFactory.throwableType, dexItemFactory.objectType);
- this.twrCloseResourceMethod =
- dexItemFactory.createMethod(
- twrUtilityClass, twrCloseResourceProto, dexItemFactory.twrCloseResourceMethodName);
+ public static boolean enableTwrCloseResourceDesugaring(InternalOptions options) {
+ return options.desugarState == DesugarState.ON
+ && options.enableTryWithResourcesDesugaring()
+ && !options.canUseTwrCloseResourceMethod();
}
- public static boolean isUtilityClassDescriptor(DexType type) {
- return type.descriptor.toString().equals(UTILITY_CLASS_DESCRIPTOR);
+ public TwrCloseResourceRewriter(AppView<?> appView) {
+ this.appView = appView;
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ twrCloseResourceProto =
+ dexItemFactory.createProto(
+ dexItemFactory.voidType, dexItemFactory.throwableType, dexItemFactory.objectType);
+ }
+
+ public int rewriteCf(ProgramMethod method, Consumer<ProgramMethod> newMethodCallback) {
+ CfCode code = method.getDefinition().getCode().asCfCode();
+ List<CfInstruction> instructions = code.getInstructions();
+ Supplier<List<CfInstruction>> lazyNewInstructions =
+ Suppliers.memoize(() -> new ArrayList<>(instructions));
+ int replaced = 0;
+ int newInstructionDelta = 0;
+ for (int i = 0; i < instructions.size(); i++) {
+ CfInvoke invoke = instructions.get(i).asInvoke();
+ if (invoke == null
+ || invoke.getOpcode() != Opcodes.INVOKESTATIC
+ || !isTwrCloseResourceMethod(invoke.getMethod(), appView.dexItemFactory())) {
+ continue;
+ }
+ // Synthesize a new method.
+ ProgramMethod closeMethod = createSyntheticCloseResourceMethod(method);
+ newMethodCallback.accept(closeMethod);
+ // Rewrite the invoke to the new synthetic.
+ int newInstructionIndex = i + newInstructionDelta;
+ lazyNewInstructions
+ .get()
+ .set(
+ newInstructionIndex,
+ new CfInvoke(Opcodes.INVOKESTATIC, closeMethod.getReference(), false));
+ ++replaced;
+ }
+ if (replaced > 0) {
+ code.setInstructions(lazyNewInstructions.get());
+ }
+ return replaced;
}
// Rewrites calls to $closeResource() method. Can be invoked concurrently.
- public void rewriteMethodCode(IRCode code) {
+ public void rewriteIR(IRCode code) {
InstructionListIterator iterator = code.instructionListIterator();
- AppInfo appInfo = appView.appInfo();
while (iterator.hasNext()) {
- Instruction instruction = iterator.next();
- if (!instruction.isInvokeStatic()) {
- continue;
- }
- InvokeStatic invoke = instruction.asInvokeStatic();
- if (!isSynthesizedCloseResourceMethod(invoke.getInvokedMethod(), appView)) {
+ InvokeStatic invoke = iterator.next().asInvokeStatic();
+ if (invoke == null
+ || !isTwrCloseResourceMethod(invoke.getInvokedMethod(), appView.dexItemFactory())) {
continue;
}
- // Replace with a call to a synthetic utility with the only
- // implementation of the method $closeResource.
+ // Replace with a call to a synthetic utility.
assert invoke.outValue() == null;
assert invoke.inValues().size() == 2;
- iterator.replaceCurrentInstruction(
- new InvokeStatic(twrCloseResourceMethod, null, invoke.inValues()));
-
- // Mark as a class referencing utility class.
- referencingClasses.add(appInfo.definitionFor(code.method().getHolderType()).asProgramClass());
+ ProgramMethod closeResourceMethod = createSyntheticCloseResourceMethod(code.context());
+ InvokeStatic newInvoke =
+ new InvokeStatic(closeResourceMethod.getReference(), null, invoke.inValues());
+ iterator.replaceCurrentInstruction(newInvoke);
+ synchronized (synthesizedMethods) {
+ synthesizedMethods.add(closeResourceMethod);
+ }
}
}
- public static boolean isSynthesizedCloseResourceMethod(DexMethod method, AppView<?> appView) {
- DexMethod original = appView.graphLens().getOriginalMethodSignature(method);
- assert original != null;
- // We consider all methods of *any* class with expected name and signature
- // to be synthesized by java 9 compiler for try-with-resources, reasoning:
- //
- // * we need to look to all potential classes because the calls might be
- // moved by inlining.
- // * theoretically we could check appropriate encoded method for having
- // right attributes, but it still does not guarantee much since we also
- // need to look into code and doing this seems an overkill
- //
- DexItemFactory dexItemFactory = appView.dexItemFactory();
- return original.name == dexItemFactory.twrCloseResourceMethodName
- && original.proto == dexItemFactory.twrCloseResourceMethodProto;
+ public static boolean isTwrCloseResourceMethod(DexMethod method, DexItemFactory factory) {
+ return method.name == factory.twrCloseResourceMethodName
+ && method.proto == factory.twrCloseResourceMethodProto;
}
- public void synthesizeUtilityClass(
- Builder<?> builder, ExecutorService executorService, InternalOptions options)
- throws ExecutionException {
- if (referencingClasses.isEmpty()) {
- return;
- }
+ private ProgramMethod createSyntheticCloseResourceMethod(ProgramMethod method) {
+ return appView
+ .getSyntheticItems()
+ .createMethod(
+ SyntheticKind.TWR_CLOSE_RESOURCE,
+ method,
+ appView.dexItemFactory(),
+ methodBuilder ->
+ methodBuilder
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setProto(twrCloseResourceProto)
+ .setCode(
+ m ->
+ BackportedMethods.CloseResourceMethod_closeResourceImpl(
+ appView.options(), m)));
+ }
- // The only encoded method.
- CfCode code =
- BackportedMethods.CloseResourceMethod_closeResourceImpl(options, twrCloseResourceMethod);
- MethodAccessFlags flags =
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false);
- DexEncodedMethod method =
- new DexEncodedMethod(
- twrCloseResourceMethod,
- flags,
- MethodTypeSignature.noSignature(),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- code,
- true);
-
- // Create utility class.
- DexProgramClass utilityClass =
- new DexProgramClass(
- twrCloseResourceMethod.holder,
- null,
- new SynthesizedOrigin("twr utility class", getClass()),
- ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC),
- appView.dexItemFactory().objectType,
- DexTypeList.empty(),
- null,
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- new DexEncodedMethod[] {method},
- DexEncodedMethod.EMPTY_ARRAY,
- appView.dexItemFactory().getSkipNameValidationForTesting(),
- DexProgramClass::checksumFromType,
- referencingClasses);
-
- // Process created class and method.
- AppInfo appInfo = appView.appInfo();
- MainDexClasses mainDexClasses = appInfo.getMainDexClasses();
- boolean addToMainDexList = mainDexClasses.containsAnyOf(referencingClasses);
- appInfo.addSynthesizedClass(utilityClass, addToMainDexList);
- converter.optimizeSynthesizedClass(utilityClass, executorService);
- builder.addSynthesizedClass(utilityClass);
+ public void processSynthesizedMethods(IRConverter converter) {
+ synthesizedMethods.forEach(converter::optimizeSynthesizedMethod);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBasedAccessDesugaring.java
new file mode 100644
index 0000000..9fcf485
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBasedAccessDesugaring.java
@@ -0,0 +1,178 @@
+// 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.ir.desugar.nest;
+
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.reportDependencyEdge;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ClasspathMethod;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndField;
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Responsible for reporting desugar dependencies and for synthesizing bridges in the program for
+ * accesses from the classpath into the program.
+ */
+public class D8NestBasedAccessDesugaring extends NestBasedAccessDesugaring {
+
+ public D8NestBasedAccessDesugaring(AppView<?> appView) {
+ super(appView);
+ }
+
+ public void reportDesugarDependencies() {
+ forEachNest(
+ nest -> {
+ if (nest.hasMissingMembers()) {
+ throw appView.options().errorMissingNestMember(nest);
+ }
+ DexClass hostClass = nest.getHostClass();
+ for (DexClass memberClass : nest.getMembers()) {
+ if (hostClass.isProgramClass() || memberClass.isProgramClass()) {
+ reportDependencyEdge(hostClass, memberClass, appView.options());
+ reportDependencyEdge(memberClass, hostClass, appView.options());
+ }
+ }
+ },
+ classWithoutHost -> {
+ throw appView.options().errorMissingNestHost(classWithoutHost);
+ });
+ }
+
+ public void synthesizeBridgesForNestBasedAccessesOnClasspath(
+ MethodProcessor methodProcessor, ExecutorService executorService) throws ExecutionException {
+ List<DexClasspathClass> classpathClassesInNests = new ArrayList<>();
+ forEachNest(
+ nest -> {
+ if (nest.getHostClass().isClasspathClass()) {
+ classpathClassesInNests.add(nest.getHostClass().asClasspathClass());
+ }
+ Iterables.addAll(classpathClassesInNests, nest.getClasspathMembers());
+ });
+
+ NestBridgeConsumer bridgeConsumer = NestBridgeConsumer.createForD8(methodProcessor);
+ ThreadUtils.processItems(
+ classpathClassesInNests,
+ clazz -> synthesizeBridgesForNestBasedAccessesOnClasspath(clazz, bridgeConsumer),
+ executorService);
+ }
+
+ public void synthesizeBridgesForNestBasedAccessesOnClasspath(
+ DexClasspathClass clazz, NestBridgeConsumer bridgeConsumer) {
+ clazz.forEachClasspathMethod(
+ method ->
+ method.registerCodeReferencesForDesugaring(
+ new NestBasedAccessDesugaringUseRegistry(method, bridgeConsumer)));
+ }
+
+ private class NestBasedAccessDesugaringUseRegistry extends UseRegistry {
+
+ private final NestBridgeConsumer bridgeConsumer;
+ private final ClasspathMethod context;
+
+ NestBasedAccessDesugaringUseRegistry(
+ ClasspathMethod context, NestBridgeConsumer bridgeConsumer) {
+ super(appView.dexItemFactory());
+ this.bridgeConsumer = bridgeConsumer;
+ this.context = context;
+ }
+
+ private void registerFieldAccess(DexField reference, boolean isGet) {
+ DexClassAndField field =
+ reference.lookupMemberOnClass(appView.definitionForHolder(reference));
+ if (field != null && needsDesugaring(field, context)) {
+ ensureFieldAccessBridge(field, isGet, bridgeConsumer);
+ }
+ }
+
+ private void registerInvoke(DexMethod reference) {
+ if (!reference.getHolderType().isClassType()) {
+ return;
+ }
+ DexClassAndMethod method =
+ reference.lookupMemberOnClass(appView.definitionForHolder(reference));
+ if (method != null && needsDesugaring(method, context)) {
+ ensureMethodBridge(method, bridgeConsumer);
+ }
+ }
+
+ @Override
+ public void registerInvokeDirect(DexMethod method) {
+ registerInvoke(method);
+ }
+
+ @Override
+ public void registerInvokeInterface(DexMethod method) {
+ registerInvoke(method);
+ }
+
+ @Override
+ public void registerInvokeStatic(DexMethod method) {
+ registerInvoke(method);
+ }
+
+ @Override
+ public void registerInvokeSuper(DexMethod method) {
+ registerInvoke(method);
+ }
+
+ @Override
+ public void registerInvokeVirtual(DexMethod method) {
+ registerInvoke(method);
+ }
+
+ @Override
+ public void registerInstanceFieldWrite(DexField field) {
+ registerFieldAccess(field, false);
+ }
+
+ @Override
+ public void registerInstanceFieldRead(DexField field) {
+ registerFieldAccess(field, true);
+ }
+
+ @Override
+ public void registerStaticFieldRead(DexField field) {
+ registerFieldAccess(field, true);
+ }
+
+ @Override
+ public void registerStaticFieldWrite(DexField field) {
+ registerFieldAccess(field, false);
+ }
+
+ @Override
+ public void registerInitClass(DexType clazz) {
+ // Intentionally empty.
+ }
+
+ @Override
+ public void registerInstanceOf(DexType type) {
+ // Intentionally empty.
+ }
+
+ @Override
+ public void registerNewInstance(DexType type) {
+ // Intentionally empty.
+ }
+
+ @Override
+ public void registerTypeReference(DexType type) {
+ // Intentionally empty.
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBridgeConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBridgeConsumer.java
new file mode 100644
index 0000000..7468cba
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/D8NestBridgeConsumer.java
@@ -0,0 +1,33 @@
+// 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.ir.desugar.nest;
+
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
+
+public class D8NestBridgeConsumer extends NestBridgeConsumer {
+
+ private final MethodProcessor methodProcessor;
+
+ public D8NestBridgeConsumer(MethodProcessor methodProcessor) {
+ this.methodProcessor = methodProcessor;
+ }
+
+ @Override
+ public void acceptFieldGetBridge(ProgramField target, ProgramMethod bridge) {
+ methodProcessor.scheduleMethodForProcessingAfterCurrentWave(bridge);
+ }
+
+ @Override
+ public void acceptFieldPutBridge(ProgramField target, ProgramMethod bridge) {
+ methodProcessor.scheduleMethodForProcessingAfterCurrentWave(bridge);
+ }
+
+ @Override
+ public void acceptMethodBridge(ProgramMethod target, ProgramMethod bridge) {
+ methodProcessor.scheduleMethodForProcessingAfterCurrentWave(bridge);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/Nest.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/Nest.java
new file mode 100644
index 0000000..979eb9c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/Nest.java
@@ -0,0 +1,83 @@
+// 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.ir.desugar.nest;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexType;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+public class Nest {
+
+ private final DexClass hostClass;
+ private final List<DexClass> members;
+ private final List<DexType> missingMembers;
+
+ private Nest(DexClass hostClass, List<DexClass> members, List<DexType> missingMembers) {
+ this.hostClass = hostClass;
+ this.members = members;
+ this.missingMembers = missingMembers;
+ }
+
+ public static Nest create(AppView<?> appView, DexClass clazz) {
+ return create(appView, clazz, null);
+ }
+
+ public static Nest create(
+ AppView<?> appView, DexClass clazz, Consumer<DexClass> missingHostConsumer) {
+ assert clazz.isInANest();
+
+ DexClass hostClass = clazz.isNestHost() ? clazz : appView.definitionFor(clazz.getNestHost());
+ if (hostClass == null) {
+ // Missing nest host means the class is considered as not being part of a nest.
+ if (missingHostConsumer != null) {
+ missingHostConsumer.accept(clazz);
+ }
+ return null;
+ }
+
+ List<DexClass> members = new ArrayList<>(hostClass.getNestMembersClassAttributes().size());
+ List<DexType> missingMembers = new ArrayList<>();
+ hostClass.forEachNestMember(
+ memberType -> {
+ DexClass memberClass = appView.definitionFor(memberType);
+ if (memberClass != null) {
+ members.add(memberClass);
+ } else {
+ missingMembers.add(memberType);
+ }
+ });
+ return new Nest(hostClass, members, missingMembers);
+ }
+
+ public Iterable<DexClasspathClass> getClasspathMembers() {
+ return Iterables.transform(
+ Iterables.filter(members, DexClass::isClasspathClass), DexClass::asClasspathClass);
+ }
+
+ public DexClass getHostClass() {
+ return hostClass;
+ }
+
+ public List<DexClass> getMembers() {
+ return members;
+ }
+
+ public List<DexType> getMissingMembers() {
+ return missingMembers;
+ }
+
+ public boolean hasLibraryMember() {
+ return Iterables.any(members, DexClass::isLibraryClass);
+ }
+
+ public boolean hasMissingMembers() {
+ return !missingMembers.isEmpty();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
new file mode 100644
index 0000000..cbaa05a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
@@ -0,0 +1,382 @@
+// 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.ir.desugar.nest;
+
+import static com.android.tools.r8.utils.ConsumerUtils.emptyConsumer;
+
+import com.android.tools.r8.cf.code.CfConstNull;
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndField;
+import com.android.tools.r8.graph.DexClassAndMember;
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMember;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.GenericSignature.ClassSignature;
+import com.android.tools.r8.graph.LibraryMember;
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.objectweb.asm.Opcodes;
+
+// NestBasedAccessDesugaring contains common code between the two subclasses
+// which are specialized for d8 and r8
+public class NestBasedAccessDesugaring {
+
+ // Short names to avoid creating long strings
+ public static final String NEST_ACCESS_NAME_PREFIX = "-$$Nest$";
+ private static final String NEST_ACCESS_METHOD_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "m";
+ private static final String NEST_ACCESS_STATIC_METHOD_NAME_PREFIX =
+ NEST_ACCESS_NAME_PREFIX + "sm";
+ private static final String NEST_ACCESS_FIELD_GET_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "fget";
+ private static final String NEST_ACCESS_STATIC_GET_FIELD_NAME_PREFIX =
+ NEST_ACCESS_NAME_PREFIX + "sfget";
+ private static final String NEST_ACCESS_FIELD_PUT_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "fput";
+ private static final String NEST_ACCESS_STATIC_PUT_FIELD_NAME_PREFIX =
+ NEST_ACCESS_NAME_PREFIX + "sfput";
+ public static final String NEST_CONSTRUCTOR_NAME = NEST_ACCESS_NAME_PREFIX + "Constructor";
+
+ protected final AppView<?> appView;
+ private final DexItemFactory dexItemFactory;
+
+ // Common single empty class for nest based private constructors
+ private DexProgramClass nestConstructor;
+ private boolean nestConstructorUsed;
+
+ public NestBasedAccessDesugaring(AppView<?> appView) {
+ this.appView = appView;
+ this.dexItemFactory = appView.dexItemFactory();
+ }
+
+ void forEachNest(Consumer<Nest> consumer) {
+ forEachNest(consumer, emptyConsumer());
+ }
+
+ void forEachNest(Consumer<Nest> consumer, Consumer<DexClass> missingHostConsumer) {
+ Set<DexType> seenNestHosts = Sets.newIdentityHashSet();
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ if (!clazz.isInANest() || !seenNestHosts.add(clazz.getNestHost())) {
+ continue;
+ }
+
+ Nest nest = Nest.create(appView, clazz, missingHostConsumer);
+ if (nest != null) {
+ consumer.accept(nest);
+ }
+ }
+ }
+
+ public boolean needsDesugaring(ProgramMethod method) {
+ if (!method.getHolder().isInANest() || !method.getDefinition().hasCode()) {
+ return false;
+ }
+
+ Code code = method.getDefinition().getCode();
+ if (code.isDexCode()) {
+ assert appView.testing().allowDexInputForTesting;
+ return false;
+ }
+
+ if (!code.isCfCode()) {
+ throw new Unreachable("Unexpected attempt to determine if non-CF code needs desugaring");
+ }
+
+ return Iterables.any(
+ code.asCfCode().getInstructions(), instruction -> needsDesugaring(instruction, method));
+ }
+
+ private boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+ if (instruction.isFieldInstruction()) {
+ return needsDesugaring(instruction.asFieldInstruction().getField(), context);
+ }
+ if (instruction.isInvoke()) {
+ return needsDesugaring(instruction.asInvoke().getMethod(), context);
+ }
+ return false;
+ }
+
+ public boolean needsDesugaring(DexMember<?, ?> memberReference, ProgramMethod context) {
+ if (!context.getHolder().isInANest() || !memberReference.getHolderType().isClassType()) {
+ return false;
+ }
+ DexClass holder = appView.definitionForHolder(memberReference, context);
+ DexClassAndMember<?, ?> member = memberReference.lookupMemberOnClass(holder);
+ return member != null && needsDesugaring(member, context);
+ }
+
+ public boolean needsDesugaring(DexClassAndMember<?, ?> member, DexClassAndMethod context) {
+ return member.getAccessFlags().isPrivate()
+ && member.getHolderType() != context.getHolderType()
+ && member.getHolder().isInANest()
+ && member.getHolder().getNestHost() == context.getHolder().getNestHost();
+ }
+
+ public boolean desugar(ProgramMethod method) {
+ return desugar(method, null);
+ }
+
+ public boolean desugar(ProgramMethod method, NestBridgeConsumer bridgeConsumer) {
+ if (!method.getHolder().isInANest()) {
+ return false;
+ }
+
+ Code code = method.getDefinition().getCode();
+ if (!code.isCfCode()) {
+ appView
+ .options()
+ .reporter
+ .error(
+ new StringDiagnostic(
+ "Unsupported attempt to desugar non-CF code",
+ method.getOrigin(),
+ method.getPosition()));
+ return false;
+ }
+
+ CfCode cfCode = code.asCfCode();
+ List<CfInstruction> desugaredInstructions =
+ ListUtils.flatMap(
+ cfCode.getInstructions(),
+ instruction -> desugarInstruction(instruction, method, bridgeConsumer),
+ null);
+ if (desugaredInstructions != null) {
+ cfCode.setInstructions(desugaredInstructions);
+ return true;
+ }
+ return false;
+ }
+
+ public List<CfInstruction> desugarInstruction(
+ CfInstruction instruction, ProgramMethod context, NestBridgeConsumer bridgeConsumer) {
+ if (instruction.isFieldInstruction()) {
+ return desugarFieldInstruction(instruction.asFieldInstruction(), context, bridgeConsumer);
+ }
+ if (instruction.isInvoke()) {
+ return desugarInvokeInstruction(instruction.asInvoke(), context, bridgeConsumer);
+ }
+ return null;
+ }
+
+ private List<CfInstruction> desugarFieldInstruction(
+ CfFieldInstruction instruction, ProgramMethod context, NestBridgeConsumer bridgeConsumer) {
+ // Since we only need to desugar accesses to private fields, and all accesses to private
+ // fields must be accessing the private field directly on its holder, we can lookup the
+ // field on the holder instead of resolving the field.
+ DexClass holder = appView.definitionForHolder(instruction.getField(), context);
+ DexClassAndField field = instruction.getField().lookupMemberOnClass(holder);
+ if (field == null || !needsDesugaring(field, context)) {
+ return null;
+ }
+
+ DexMethod bridge = ensureFieldAccessBridge(field, instruction.isFieldGet(), bridgeConsumer);
+ return ImmutableList.of(
+ new CfInvoke(Opcodes.INVOKESTATIC, bridge, field.getHolder().isInterface()));
+ }
+
+ private List<CfInstruction> desugarInvokeInstruction(
+ CfInvoke invoke, ProgramMethod context, NestBridgeConsumer bridgeConsumer) {
+ DexMethod invokedMethod = invoke.getMethod();
+ if (!invokedMethod.getHolderType().isClassType()) {
+ return null;
+ }
+
+ // Since we only need to desugar accesses to private methods, and all accesses to private
+ // methods must be accessing the private method directly on its holder, we can lookup the
+ // method on the holder instead of resolving the method.
+ DexClass holder = appView.definitionForHolder(invokedMethod, context);
+ DexClassAndMethod target = invokedMethod.lookupMemberOnClass(holder);
+ if (target == null || !needsDesugaring(target, context)) {
+ return null;
+ }
+
+ DexMethod bridge = ensureMethodBridge(target, bridgeConsumer);
+ if (target.getDefinition().isInstanceInitializer()) {
+ assert !invoke.isInterface();
+ return ImmutableList.of(
+ new CfConstNull(), new CfInvoke(Opcodes.INVOKESPECIAL, bridge, false));
+ }
+
+ return ImmutableList.of(new CfInvoke(Opcodes.INVOKESTATIC, bridge, invoke.isInterface()));
+ }
+
+ private RuntimeException reportIncompleteNest(LibraryMember<?, ?> member) {
+ Nest nest = Nest.create(appView, member.getHolder());
+ assert nest != null : "Should be a compilation error if missing nest host on library class.";
+ throw appView.options().errorMissingNestMember(nest);
+ }
+
+ private DexProgramClass createNestAccessConstructor() {
+ // TODO(b/176900254): ensure hygienic synthetic class.
+ return new DexProgramClass(
+ dexItemFactory.nestConstructorType,
+ null,
+ new SynthesizedOrigin("Nest based access desugaring", getClass()),
+ // Make the synthesized class public since shared in the whole program.
+ ClassAccessFlags.fromDexAccessFlags(
+ Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
+ dexItemFactory.objectType,
+ DexTypeList.empty(),
+ dexItemFactory.createString("nest"),
+ null,
+ Collections.emptyList(),
+ null,
+ Collections.emptyList(),
+ ClassSignature.noSignature(),
+ DexAnnotationSet.empty(),
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedMethod.EMPTY_ARRAY,
+ DexEncodedMethod.EMPTY_ARRAY,
+ dexItemFactory.getSkipNameValidationForTesting(),
+ DexProgramClass::checksumFromType);
+ }
+
+ public DexProgramClass synthesizeNestConstructor() {
+ if (nestConstructorUsed && nestConstructor == null) {
+ nestConstructor = createNestAccessConstructor();
+ return nestConstructor;
+ }
+ return null;
+ }
+
+ DexMethod ensureFieldAccessBridge(
+ DexClassAndField field, boolean isGet, NestBridgeConsumer bridgeConsumer) {
+ if (field.isProgramField()) {
+ return ensureFieldAccessBridge(field.asProgramField(), isGet, bridgeConsumer);
+ }
+ if (field.isClasspathField()) {
+ return getFieldAccessBridgeReference(field, isGet);
+ }
+ assert field.isLibraryField();
+ throw reportIncompleteNest(field.asLibraryField());
+ }
+
+ private DexMethod ensureFieldAccessBridge(
+ ProgramField field, boolean isGet, NestBridgeConsumer bridgeConsumer) {
+ DexMethod bridgeReference = getFieldAccessBridgeReference(field, isGet);
+ synchronized (field.getHolder().getMethodCollection()) {
+ ProgramMethod bridge = field.getHolder().lookupProgramMethod(bridgeReference);
+ if (bridge == null) {
+ bridge = DexEncodedMethod.createFieldAccessorBridge(field, isGet, bridgeReference);
+ bridge.getHolder().addDirectMethod(bridge.getDefinition());
+ if (bridgeConsumer != null) {
+ bridgeConsumer.acceptFieldBridge(field, bridge, isGet);
+ }
+ }
+ return bridge.getReference();
+ }
+ }
+
+ private DexMethod getFieldAccessBridgeReference(DexClassAndField field, boolean isGet) {
+ int bridgeParameterCount =
+ BooleanUtils.intValue(!field.getAccessFlags().isStatic()) + BooleanUtils.intValue(!isGet);
+ DexType[] parameters = new DexType[bridgeParameterCount];
+ if (!isGet) {
+ parameters[parameters.length - 1] = field.getType();
+ }
+ if (!field.getAccessFlags().isStatic()) {
+ parameters[0] = field.getHolderType();
+ }
+ DexType returnType = isGet ? field.getType() : dexItemFactory.voidType;
+ DexProto proto = dexItemFactory.createProto(returnType, parameters);
+ return dexItemFactory.createMethod(
+ field.getHolderType(), proto, getFieldAccessBridgeName(field, isGet));
+ }
+
+ private DexString getFieldAccessBridgeName(DexClassAndField field, boolean isGet) {
+ String prefix;
+ if (isGet && !field.getAccessFlags().isStatic()) {
+ prefix = NEST_ACCESS_FIELD_GET_NAME_PREFIX;
+ } else if (isGet) {
+ prefix = NEST_ACCESS_STATIC_GET_FIELD_NAME_PREFIX;
+ } else if (!field.getAccessFlags().isStatic()) {
+ prefix = NEST_ACCESS_FIELD_PUT_NAME_PREFIX;
+ } else {
+ prefix = NEST_ACCESS_STATIC_PUT_FIELD_NAME_PREFIX;
+ }
+ return dexItemFactory.createString(prefix + field.getName().toString());
+ }
+
+ DexMethod ensureMethodBridge(DexClassAndMethod method, NestBridgeConsumer bridgeConsumer) {
+ if (method.isProgramMethod()) {
+ return ensureMethodBridge(method.asProgramMethod(), bridgeConsumer);
+ }
+ if (method.isClasspathMethod()) {
+ return getMethodBridgeReference(method);
+ }
+ assert method.isLibraryMethod();
+ throw reportIncompleteNest(method.asLibraryMethod());
+ }
+
+ private DexMethod ensureMethodBridge(ProgramMethod method, NestBridgeConsumer bridgeConsumer) {
+ DexMethod bridgeReference = getMethodBridgeReference(method);
+ synchronized (method.getHolder().getMethodCollection()) {
+ ProgramMethod bridge = method.getHolder().lookupProgramMethod(bridgeReference);
+ if (bridge == null) {
+ DexEncodedMethod definition = method.getDefinition();
+ bridge =
+ definition.isInstanceInitializer()
+ ? definition.toInitializerForwardingBridge(
+ method.getHolder(), bridgeReference, dexItemFactory)
+ : definition.toStaticForwardingBridge(
+ method.getHolder(), bridgeReference, dexItemFactory);
+ bridge.getHolder().addDirectMethod(bridge.getDefinition());
+ if (bridgeConsumer != null) {
+ bridgeConsumer.acceptMethodBridge(method, bridge);
+ }
+ }
+ }
+ return bridgeReference;
+ }
+
+ private DexMethod getMethodBridgeReference(DexClassAndMethod method) {
+ if (method.getDefinition().isInstanceInitializer()) {
+ DexProto newProto =
+ dexItemFactory.appendTypeToProto(method.getProto(), dexItemFactory.nestConstructorType);
+ nestConstructorUsed = true;
+ return method.getReference().withProto(newProto, dexItemFactory);
+ }
+ DexProto proto =
+ method.getAccessFlags().isStatic()
+ ? method.getProto()
+ : dexItemFactory.prependHolderToProto(method.getReference());
+ return dexItemFactory.createMethod(method.getHolderType(), proto, getMethodBridgeName(method));
+ }
+
+ private DexString getMethodBridgeName(DexClassAndMethod method) {
+ String prefix =
+ method.getAccessFlags().isStatic()
+ ? NEST_ACCESS_STATIC_METHOD_NAME_PREFIX
+ : NEST_ACCESS_METHOD_NAME_PREFIX;
+ return dexItemFactory.createString(prefix + method.getName().toString());
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBridgeConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBridgeConsumer.java
new file mode 100644
index 0000000..e6a8a03
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBridgeConsumer.java
@@ -0,0 +1,30 @@
+// 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.ir.desugar.nest;
+
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
+
+public abstract class NestBridgeConsumer {
+
+ public static D8NestBridgeConsumer createForD8(MethodProcessor methodProcessor) {
+ return new D8NestBridgeConsumer(methodProcessor);
+ }
+
+ public abstract void acceptFieldGetBridge(ProgramField target, ProgramMethod bridge);
+
+ public abstract void acceptFieldPutBridge(ProgramField target, ProgramMethod bridge);
+
+ public abstract void acceptMethodBridge(ProgramMethod target, ProgramMethod bridge);
+
+ public final void acceptFieldBridge(ProgramField target, ProgramMethod bridge, boolean isGet) {
+ if (isGet) {
+ acceptFieldGetBridge(target, bridge);
+ } else {
+ acceptFieldPutBridge(target, bridge);
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
index d6eae9a..ddb7ff5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
@@ -6,11 +6,12 @@
import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
import static com.google.common.base.Predicates.alwaysTrue;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndField;
import com.android.tools.r8.graph.DexClassAndMethod;
-import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -33,7 +34,9 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
-import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfo;
+import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfoLookup;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.TriConsumer;
import com.android.tools.r8.utils.TriFunction;
@@ -56,12 +59,10 @@
public class AssumeInserter {
- private final AppView<? extends AppInfoWithClassHierarchy> appView;
- private final InternalOptions options;
+ private final AppView<AppInfoWithLiveness> appView;
- public AssumeInserter(AppView<? extends AppInfoWithClassHierarchy> appView) {
+ public AssumeInserter(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
- this.options = appView.options();
}
public void insertAssumeInstructions(IRCode code, Timing timing) {
@@ -225,7 +226,26 @@
private boolean computeAssumedValuesFromSingleTarget(
IRCode code, InvokeMethod invoke, AssumedValues.Builder assumedValuesBuilder) {
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .unsafeResolveMethodDueToDexFormat(invoke.getInvokedMethod())
+ .asSingleResolution();
+ if (resolutionResult == null) {
+ return false;
+ }
+
DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, code.context());
+ if (invoke.hasUsedOutValue() && invoke.getOutType().isReferenceType()) {
+ AssumeInfo assumeInfo =
+ AssumeInfoLookup.lookupAssumeInfo(appView, resolutionResult, singleTarget);
+ if (assumeInfo != null
+ && assumeInfo.hasReturnInfo()
+ && assumeInfo.getReturnInfo().isNonNull()) {
+ assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(invoke, invoke.outValue());
+ }
+ }
+
if (singleTarget == null) {
return false;
}
@@ -234,12 +254,11 @@
MethodOptimizationInfo optimizationInfo = singleTarget.getDefinition().getOptimizationInfo();
// Case (2), invocations that are guaranteed to return a non-null value.
- Value outValue = invoke.outValue();
- if (outValue != null && outValue.hasNonDebugUsers()) {
+ if (invoke.hasUsedOutValue()) {
needsAssumeInstruction =
computeAssumedValuesForOutValue(
invoke,
- optimizationInfo.getDynamicUpperBoundTypeOrElse(outValue.getType()),
+ optimizationInfo.getDynamicUpperBoundTypeOrElse(invoke.getOutType()),
optimizationInfo.getDynamicLowerBoundType(),
assumedValuesBuilder);
}
@@ -264,20 +283,31 @@
private boolean computeAssumedValuesForFieldGet(
FieldInstruction fieldGet, AssumedValues.Builder assumedValuesBuilder) {
- Value outValue = fieldGet.outValue();
- if (!outValue.hasNonDebugUsers()) {
+ if (fieldGet.hasUnusedOutValue()) {
return false;
}
- DexEncodedField field = appView.appInfo().resolveField(fieldGet.getField()).getResolvedField();
- if (field == null) {
+ SuccessfulFieldResolutionResult resolutionResult =
+ appView.appInfo().resolveField(fieldGet.getField()).asSuccessfulResolution();
+ if (resolutionResult == null) {
return false;
}
- FieldOptimizationInfo optimizationInfo = field.getOptimizationInfo();
+ DexClassAndField field = resolutionResult.getResolutionPair();
+
+ if (field.getType().isReferenceType()) {
+ AssumeInfo assumeInfo = AssumeInfoLookup.lookupAssumeInfo(appView, field);
+ if (assumeInfo != null
+ && assumeInfo.hasReturnInfo()
+ && assumeInfo.getReturnInfo().isNonNull()) {
+ assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(fieldGet, fieldGet.outValue());
+ }
+ }
+
+ FieldOptimizationInfo optimizationInfo = field.getDefinition().getOptimizationInfo();
return computeAssumedValuesForOutValue(
fieldGet,
- optimizationInfo.getDynamicUpperBoundTypeOrElse(outValue.getType()),
+ optimizationInfo.getDynamicUpperBoundTypeOrElse(fieldGet.getOutType()),
optimizationInfo.getDynamicLowerBoundType(),
assumedValuesBuilder);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 89d9eb7..5112116 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -954,7 +954,10 @@
return rewriteSwitch(code, SwitchCaseAnalyzer.getInstance());
}
- public boolean rewriteSwitch(IRCode code, SwitchCaseAnalyzer switchCaseAnalyzer) {
+ private boolean rewriteSwitch(IRCode code, SwitchCaseAnalyzer switchCaseAnalyzer) {
+ if (!options.isSwitchRewritingEnabled()) {
+ return false;
+ }
if (!code.metadata().mayHaveSwitch()) {
return false;
}
@@ -1473,19 +1476,16 @@
UtilityMethodForCodeOptimizations throwClassCastExceptionIfNotNullMethod =
UtilityMethodsForCodeOptimizations.synthesizeThrowClassCastExceptionIfNotNullMethod(
appView, context, methodProcessingId);
- // TODO(b/172194277): Allow synthetics when generating CF.
- if (throwClassCastExceptionIfNotNullMethod != null) {
- throwClassCastExceptionIfNotNullMethod.optimize(methodProcessor);
- InvokeStatic replacement =
- InvokeStatic.builder()
- .setMethod(throwClassCastExceptionIfNotNullMethod.getMethod())
- .setSingleArgument(checkCast.object())
- .setPosition(checkCast)
- .build();
- it.replaceCurrentInstruction(replacement);
- assert replacement.lookupSingleTarget(appView, context) != null;
- return RemoveCheckCastInstructionIfTrivialResult.REMOVED_CAST_DO_NARROW;
- }
+ throwClassCastExceptionIfNotNullMethod.optimize(methodProcessor);
+ InvokeStatic replacement =
+ InvokeStatic.builder()
+ .setMethod(throwClassCastExceptionIfNotNullMethod.getMethod())
+ .setSingleArgument(checkCast.object())
+ .setPosition(checkCast)
+ .build();
+ it.replaceCurrentInstruction(replacement);
+ assert replacement.lookupSingleTarget(appView, context) != null;
+ return RemoveCheckCastInstructionIfTrivialResult.REMOVED_CAST_DO_NARROW;
}
// Otherwise, keep the checkcast to preserve verification errors. E.g., down-cast:
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
index 674488f..7179327 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
@@ -25,6 +25,7 @@
import com.android.tools.r8.ir.code.InvokeVirtual;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.MainDexTracingResult;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
@@ -47,10 +48,13 @@
public class Devirtualizer {
private final AppView<AppInfoWithLiveness> appView;
+ private final MainDexTracingResult mainDexTracingResult;
private final InternalOptions options;
- public Devirtualizer(AppView<AppInfoWithLiveness> appView) {
+ public Devirtualizer(
+ AppView<AppInfoWithLiveness> appView, MainDexTracingResult mainDexTracingResult) {
this.appView = appView;
+ this.mainDexTracingResult = mainDexTracingResult;
this.options = appView.options();
}
@@ -148,7 +152,9 @@
// Rebind the invoke to the most specific target.
DexMethod invokedMethod = invoke.getInvokedMethod();
DexClassAndMethod reboundTarget = rebindSuperInvokeToMostSpecific(invokedMethod, context);
- if (reboundTarget != null && reboundTarget.getReference() != invokedMethod) {
+ if (reboundTarget != null
+ && reboundTarget.getReference() != invokedMethod
+ && !isRebindingNewClassIntoMainDex(invokedMethod, reboundTarget.getReference())) {
it.replaceCurrentInstruction(
new InvokeSuper(
reboundTarget.getReference(),
@@ -190,6 +196,11 @@
continue;
}
+ // Ensure that we are not adding a new main dex root
+ if (isRebindingNewClassIntoMainDex(invoke.getInvokedMethod(), target.getReference())) {
+ continue;
+ }
+
InvokeVirtual devirtualizedInvoke =
new InvokeVirtual(target.getReference(), invoke.outValue(), invoke.inValues());
it.replaceCurrentInstruction(devirtualizedInvoke);
@@ -382,4 +393,14 @@
// Change the invoke-virtual instruction to target the refined resolution result instead.
return newResolutionResult.getResolvedMethod().method;
}
+
+ private boolean isRebindingNewClassIntoMainDex(
+ DexMethod originalMethod, DexMethod reboundMethod) {
+ if (!mainDexTracingResult.isRoot(originalMethod.holder)
+ && !appView.appInfo().getMainDexClasses().contains(originalMethod.holder)) {
+ return false;
+ }
+ return !mainDexTracingResult.isRoot(reboundMethod.holder)
+ && !appView.appInfo().getMainDexClasses().contains(reboundMethod.holder);
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 1cce76e..38c4e6f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -49,7 +49,6 @@
import com.android.tools.r8.ir.conversion.LensCodeRewriter;
import com.android.tools.r8.ir.conversion.MethodProcessor;
import com.android.tools.r8.ir.conversion.PostOptimization;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
import com.android.tools.r8.ir.optimize.inliner.DefaultInliningReasonStrategy;
@@ -130,9 +129,7 @@
}
if (extraNeverInlineMethods.contains(
- appView.graphLens().getOriginalMethodSignature(singleTargetReference))
- || TwrCloseResourceRewriter.isSynthesizedCloseResourceMethod(
- singleTargetReference, appView)) {
+ appView.graphLens().getOriginalMethodSignature(singleTargetReference))) {
whyAreYouNotInliningReporter.reportExtraNeverInline();
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
index 2950d4c..d92d375 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
@@ -7,19 +7,20 @@
import static com.google.common.base.Predicates.alwaysTrue;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndField;
import com.android.tools.r8.graph.DexClassAndMethod;
-import com.android.tools.r8.graph.DexDefinition;
import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.SingleValue;
+import com.android.tools.r8.ir.analysis.value.UnknownValue;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.FieldInstruction;
import com.android.tools.r8.ir.code.IRCode;
@@ -34,8 +35,9 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
+import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfo;
+import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfoLookup;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.ProguardMemberRule;
import com.android.tools.r8.shaking.ProguardMemberRuleReturnValue;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringDiagnostic;
@@ -54,48 +56,17 @@
// Fields for which we have reported warnings to due Proguard configuration rules.
private final Set<DexField> warnedFields = Sets.newIdentityHashSet();
- private enum RuleType {
- NONE,
- ASSUME_NO_SIDE_EFFECTS,
- ASSUME_VALUES
- }
-
- private static class ProguardMemberRuleLookup {
-
- final RuleType type;
- final ProguardMemberRule rule;
-
- ProguardMemberRuleLookup(RuleType type, ProguardMemberRule rule) {
- this.type = type;
- this.rule = rule;
- }
-
- @Override
- public boolean equals(Object other) {
- if (!(other instanceof ProguardMemberRuleLookup)) {
- return false;
- }
- ProguardMemberRuleLookup otherLookup = (ProguardMemberRuleLookup) other;
- return type == otherLookup.type && rule == otherLookup.rule;
- }
-
- @Override
- public int hashCode() {
- return type.ordinal() * 31 + rule.hashCode();
- }
- }
-
public MemberValuePropagation(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
this.reporter = appView.options().reporter;
}
- private boolean mayPropagateValueFor(DexEncodedField field) {
- if (field.isProgramField(appView)) {
- return appView.appInfo().mayPropagateValueFor(field.field);
+ private boolean mayPropagateValueFor(DexClassAndField field) {
+ if (field.isProgramField()) {
+ return appView.appInfo().mayPropagateValueFor(field.getReference());
}
- return appView.appInfo().assumedValues.containsKey(field.field)
- || appView.appInfo().noSideEffects.containsKey(field.field);
+ return appView.appInfo().assumedValues.containsKey(field.getReference())
+ || appView.appInfo().noSideEffects.containsKey(field.getReference());
}
private boolean mayPropagateValueFor(DexClassAndMethod method) {
@@ -106,36 +77,25 @@
|| appView.appInfo().noSideEffects.containsKey(method.getReference());
}
- private ProguardMemberRuleLookup lookupMemberRule(DexClassAndMethod method) {
- return method != null ? lookupMemberRule(method.getDefinition()) : null;
- }
-
- private ProguardMemberRuleLookup lookupMemberRule(DexDefinition definition) {
- if (definition == null) {
- return null;
- }
- DexReference reference = definition.getReference();
- ProguardMemberRule rule = appView.appInfo().noSideEffects.get(reference);
- if (rule != null) {
- return new ProguardMemberRuleLookup(RuleType.ASSUME_NO_SIDE_EFFECTS, rule);
- }
- rule = appView.appInfo().assumedValues.get(reference);
- if (rule != null) {
- return new ProguardMemberRuleLookup(RuleType.ASSUME_VALUES, rule);
- }
- return null;
- }
-
- private Instruction constantReplacementFromProguardRule(
- ProguardMemberRule rule, IRCode code, Instruction instruction) {
- if (rule == null || !rule.hasReturnValue()) {
+ private Instruction createReplacementFromAssumeInfo(
+ AssumeInfo assumeInfo, IRCode code, Instruction instruction) {
+ if (!assumeInfo.hasReturnInfo()) {
return null;
}
- ProguardMemberRuleReturnValue returnValueRule = rule.getReturnValue();
+ ProguardMemberRuleReturnValue returnValueRule = assumeInfo.getReturnInfo();
// Check if this value can be assumed constant.
if (returnValueRule.isSingleValue()) {
+ if (instruction.getOutType().isReferenceType()) {
+ if (returnValueRule.getSingleValue() == 0) {
+ return appView
+ .abstractValueFactory()
+ .createNullValue()
+ .createMaterializingInstruction(appView, code, instruction);
+ }
+ return null;
+ }
return appView.abstractValueFactory()
.createSingleNumberValue(returnValueRule.getSingleValue())
.createMaterializingInstruction(appView, code, instruction);
@@ -177,31 +137,33 @@
return null;
}
- private void setValueRangeFromProguardRule(ProguardMemberRule rule, Value value) {
- if (rule.hasReturnValue() && rule.getReturnValue().isValueRange()) {
- assert !rule.getReturnValue().isSingleValue();
- value.setValueRange(rule.getReturnValue().getValueRange());
+ private void setValueRangeFromAssumeInfo(AssumeInfo assumeInfo, Value value) {
+ if (assumeInfo.hasReturnInfo() && assumeInfo.getReturnInfo().isValueRange()) {
+ assert !assumeInfo.getReturnInfo().isSingleValue();
+ value.setValueRange(assumeInfo.getReturnInfo().getValueRange());
}
}
- private boolean tryConstantReplacementFromProguard(
+ private boolean applyAssumeInfoIfPossible(
IRCode code,
Set<Value> affectedValues,
ListIterator<BasicBlock> blocks,
InstructionListIterator iterator,
Instruction current,
- ProguardMemberRuleLookup lookup) {
- Instruction replacement = constantReplacementFromProguardRule(lookup.rule, code, current);
+ AssumeInfo assumeInfo) {
+ Instruction replacement = createReplacementFromAssumeInfo(assumeInfo, code, current);
if (replacement == null) {
// Check to see if a value range can be assumed.
- setValueRangeFromProguardRule(lookup.rule, current.outValue());
+ if (current.getOutType().isPrimitiveType()) {
+ setValueRangeFromAssumeInfo(assumeInfo, current.outValue());
+ }
return false;
}
affectedValues.addAll(current.outValue().affectedValues());
- if (lookup.type == RuleType.ASSUME_NO_SIDE_EFFECTS) {
+ if (assumeInfo.isAssumeNoSideEffects()) {
iterator.replaceCurrentInstruction(replacement);
} else {
- assert lookup.type == RuleType.ASSUME_VALUES;
+ assert assumeInfo.isAssumeValues();
BasicBlock block = current.getBlock();
Position position = current.getPosition();
if (current.hasOutValue()) {
@@ -240,43 +202,33 @@
return;
}
- DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, context);
- ProguardMemberRuleLookup lookup = lookupMemberRule(singleTarget);
- if (lookup == null) {
- // -assumenosideeffects rules are applied to upward visible and overriding methods, but only
- // references that have actual definitions are marked by the root set builder. So, here, we
- // try again with a resolved target, not the direct definition, which may not exist.
- DexEncodedMethod resolutionTarget =
- appView.appInfo().unsafeResolveMethodDueToDexFormat(invokedMethod).getSingleTarget();
- lookup = lookupMemberRule(resolutionTarget);
- }
-
- if (lookup != null) {
- // Check to see if a constant value can be assumed.
- // But, if the current matched rule is -assumenosideeffects without the return value, it won't
- // be transformed into a replacement instruction. Check if there is -assumevalues rule bound
- // to the target.
- if (singleTarget != null
- && lookup.type == RuleType.ASSUME_NO_SIDE_EFFECTS
- && !lookup.rule.hasReturnValue()) {
- ProguardMemberRule rule = appView.appInfo().assumedValues.get(singleTarget.getReference());
- if (rule != null) {
- lookup = new ProguardMemberRuleLookup(RuleType.ASSUME_VALUES, rule);
- }
- }
- if (tryConstantReplacementFromProguard(
- code, affectedValues, blocks, iterator, invoke, lookup)) {
- return;
- }
- }
-
- // No Proguard rule could replace the instruction check for knowledge about the return value.
- if (singleTarget == null || !mayPropagateValueFor(singleTarget)) {
+ SingleResolutionResult resolutionResult =
+ appView.appInfo().unsafeResolveMethodDueToDexFormat(invokedMethod).asSingleResolution();
+ if (resolutionResult == null) {
return;
}
- AbstractValue abstractReturnValue =
- singleTarget.getDefinition().getOptimizationInfo().getAbstractReturnValue();
+ DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, context);
+ AssumeInfo lookup = AssumeInfoLookup.lookupAssumeInfo(appView, resolutionResult, singleTarget);
+ if (lookup != null
+ && applyAssumeInfoIfPossible(code, affectedValues, blocks, iterator, invoke, lookup)) {
+ return;
+ }
+
+ // No Proguard rule could replace the instruction check for knowledge about the return value.
+ if (singleTarget != null && !mayPropagateValueFor(singleTarget)) {
+ return;
+ }
+
+ AbstractValue abstractReturnValue;
+ if (invokedMethod.getReturnType().isAlwaysNull(appView)) {
+ abstractReturnValue = appView.abstractValueFactory().createNullValue();
+ } else if (singleTarget != null) {
+ abstractReturnValue =
+ singleTarget.getDefinition().getOptimizationInfo().getAbstractReturnValue();
+ } else {
+ abstractReturnValue = UnknownValue.getInstance();
+ }
if (abstractReturnValue.isSingleValue()) {
SingleValue singleReturnValue = abstractReturnValue.asSingleValue();
@@ -293,7 +245,7 @@
if (invoke.isInvokeMethodWithReceiver()) {
iterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context);
- } else if (invoke.isInvokeStatic()) {
+ } else if (invoke.isInvokeStatic() && singleTarget != null) {
iterator.replaceCurrentInstructionByInitClassIfPossible(
appView, code, singleTarget.getHolderType());
}
@@ -308,7 +260,10 @@
} else {
iterator.add(replacement);
}
- singleTarget.getDefinition().getMutableOptimizationInfo().markAsPropagated();
+
+ if (singleTarget != null) {
+ singleTarget.getDefinition().getMutableOptimizationInfo().markAsPropagated();
+ }
}
}
}
@@ -322,8 +277,9 @@
DexField field = current.getField();
// TODO(b/123857022): Should be able to use definitionFor().
- DexEncodedField target = appView.appInfo().resolveField(field).getResolvedField();
- if (target == null) {
+ SuccessfulFieldResolutionResult resolutionResult =
+ appView.appInfo().resolveField(field).asSuccessfulResolution();
+ if (resolutionResult == null) {
boolean replaceCurrentInstructionWithConstNull =
appView.withGeneratedExtensionRegistryShrinker(
shrinker -> shrinker.wasRemoved(field), false);
@@ -333,7 +289,9 @@
return;
}
- if (target.isStatic() != current.isStaticGet()) {
+ DexClassAndField target = resolutionResult.getResolutionPair();
+ DexEncodedField definition = target.getDefinition();
+ if (definition.isStatic() != current.isStaticGet()) {
return;
}
@@ -342,33 +300,35 @@
}
// Check if there is a Proguard configuration rule that specifies the value of the field.
- ProguardMemberRuleLookup lookup = lookupMemberRule(target);
+ AssumeInfo lookup = AssumeInfoLookup.lookupAssumeInfo(appView, target);
if (lookup != null
- && tryConstantReplacementFromProguard(
- code, affectedValues, blocks, iterator, current, lookup)) {
+ && applyAssumeInfoIfPossible(code, affectedValues, blocks, iterator, current, lookup)) {
return;
}
AbstractValue abstractValue;
if (field.getType().isAlwaysNull(appView)) {
abstractValue = appView.abstractValueFactory().createSingleNumberValue(0);
- } else if (appView.appInfo().isFieldWrittenByFieldPutInstruction(target)) {
- abstractValue = target.getOptimizationInfo().getAbstractValue();
- if (abstractValue.isUnknown() && !target.isStatic()) {
+ } else if (appView.appInfo().isFieldWrittenByFieldPutInstruction(definition)) {
+ abstractValue = definition.getOptimizationInfo().getAbstractValue();
+ if (abstractValue.isUnknown() && !definition.isStatic()) {
AbstractValue abstractReceiverValue =
current.asInstanceGet().object().getAbstractValue(appView, code.context());
if (abstractReceiverValue.isSingleFieldValue()) {
abstractValue =
- abstractReceiverValue.asSingleFieldValue().getState().getAbstractFieldValue(target);
+ abstractReceiverValue
+ .asSingleFieldValue()
+ .getState()
+ .getAbstractFieldValue(definition);
}
}
- } else if (target.isStatic()) {
+ } else if (definition.isStatic()) {
// This is guaranteed to read the static value of the field.
- abstractValue = target.getStaticValue().toAbstractValue(appView.abstractValueFactory());
+ abstractValue = definition.getStaticValue().toAbstractValue(appView.abstractValueFactory());
// Verify that the optimization info is consistent with the static value.
- assert target.getOptimizationInfo().getAbstractValue().isUnknown()
- || !target.hasExplicitStaticValue()
- || abstractValue == target.getOptimizationInfo().getAbstractValue();
+ assert definition.getOptimizationInfo().getAbstractValue().isUnknown()
+ || !definition.hasExplicitStaticValue()
+ || abstractValue == definition.getOptimizationInfo().getAbstractValue();
} else {
// This is guaranteed to read the default value of the field.
abstractValue = appView.abstractValueFactory().createSingleNumberValue(0);
@@ -411,7 +371,8 @@
} else {
iterator.add(replacement);
}
- feedback.markFieldAsPropagated(target);
+
+ feedback.markFieldAsPropagated(definition);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NestReducer.java b/src/main/java/com/android/tools/r8/ir/optimize/NestReducer.java
index 6fa08c8..e20e28c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NestReducer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NestReducer.java
@@ -4,131 +4,102 @@
package com.android.tools.r8.ir.optimize;
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexEncodedMember;
import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.NestMemberClassAttribute;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.BooleanBox;
+import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
import com.google.common.collect.Sets;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-// This pass
-// - cleans the nests: it removes missing nest host/members from the input and
-// report them (warning or error).
-// - clears nests which do not use nest based access control to allow other
-// optimizations such as class merging to perform better.
+/**
+ * This pass:
+ *
+ * <ul>
+ * <li>cleans the nests: it removes missing nest host/members from the input,
+ * <li>clears nests which do not use nest based access control to allow other optimizations such
+ * as class merging to perform better.
+ * </ul>
+ */
public class NestReducer {
- private AppView<?> appView;
+ private AppView<AppInfoWithLiveness> appView;
- public NestReducer(AppView<?> appView) {
+ public NestReducer(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
}
- private DexClass definitionFor(DexType type) {
- assert appView.graphLens().lookupType(type) == type;
- return appView.definitionFor(appView.graphLens().lookupType(type));
+ public void run(ExecutorService executorService, Timing timing) throws ExecutionException {
+ timing.begin("NestReduction");
+ if (appView.options().shouldDesugarNests()) {
+ removeNests();
+ } else {
+ reduceNests(executorService);
+ }
+ timing.end();
}
- public void run(ExecutorService executorService) throws ExecutionException {
- Set<DexType> nestHosts = Sets.newIdentityHashSet();
- List<Future<?>> futures = new ArrayList<>();
- // It is possible that a nest member is on the program path but its nest host
- // is only in the class path.
- // Nests are therefore computed the first time a nest member is met, host or not.
- // The computedNestHosts list is there to avoid processing multiple times the same nest.
+ private void removeNests() {
for (DexProgramClass clazz : appView.appInfo().classes()) {
- DexType hostType = clazz.getNestHost();
- if (hostType != null && !nestHosts.contains(hostType)) {
- nestHosts.add(hostType);
- futures.add(
- executorService.submit(
- () -> {
- processNestFrom(clazz);
- return null; // we want a Callable not a Runnable to be able to throw
- }));
- }
- }
- ThreadUtils.awaitFutures(futures);
- }
-
- private void processNestFrom(DexClass clazz) {
- DexClass nestHost = definitionFor(clazz.getNestHost());
- if (nestHost == null) {
- reportMissingNestHost(clazz);
- clazz.clearNestHost();
- return;
- }
- boolean hasPrivateMembers = hasPrivateMembers(nestHost);
- Iterator<NestMemberClassAttribute> iterator =
- nestHost.getNestMembersClassAttributes().iterator();
- boolean reported = false;
- while (iterator.hasNext()) {
- DexClass member = definitionFor(iterator.next().getNestMember());
- if (member == null) {
- if (!reported) {
- reported = true;
- reportIncompleteNest(nestHost);
+ if (clazz.isInANest()) {
+ if (clazz.isNestHost()) {
+ clazz.clearNestMembers();
+ } else {
+ clazz.clearNestHost();
}
- iterator.remove();
- } else {
- hasPrivateMembers = hasPrivateMembers || hasPrivateMembers(member);
}
}
- if (!hasPrivateMembers && appView.options().enableNestReduction) {
- clearNestAttributes(nestHost);
- }
}
- private void reportMissingNestHost(DexClass clazz) {
- if (appView.options().ignoreMissingClasses) {
- appView.options().warningMissingClassMissingNestHost(clazz);
- } else {
- appView.options().errorMissingClassMissingNestHost(clazz);
- }
- }
-
- private void reportIncompleteNest(DexClass nestHost) {
- List<DexType> nest = new ArrayList<>(nestHost.getNestMembersClassAttributes().size() + 1);
- for (NestMemberClassAttribute attr : nestHost.getNestMembersClassAttributes()) {
- nest.add(attr.getNestMember());
- }
- nest.add(nestHost.type);
- if (appView.options().ignoreMissingClasses) {
- appView.options().warningMissingClassIncompleteNest(nest, appView);
- } else {
- appView.options().errorMissingClassIncompleteNest(nest, appView);
- }
- }
-
- private void clearNestAttributes(DexClass nestHost) {
- nestHost.getNestMembersClassAttributes().clear();
- for (NestMemberClassAttribute attr : nestHost.getNestMembersClassAttributes()) {
- DexClass member = appView.definitionFor(appView.graphLens().lookupType(attr.getNestMember()));
- member.clearNestHost();
- }
- }
-
- private boolean hasPrivateMembers(DexClass clazz) {
- for (DexEncodedMethod method : clazz.methods()) {
- if (method.accessFlags.isPrivate()) {
- return true;
+ private void reduceNests(ExecutorService executorService) throws ExecutionException {
+ Set<DexProgramClass> nestHosts = Sets.newIdentityHashSet();
+ Set<DexProgramClass> nestMembers = Sets.newIdentityHashSet();
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ if (clazz.isInANest()) {
+ if (clazz.isNestHost()) {
+ nestHosts.add(clazz);
+ } else {
+ nestMembers.add(clazz);
+ }
}
}
- for (DexEncodedField field : clazz.fields()) {
- if (field.accessFlags.isPrivate()) {
- return true;
- }
+ ThreadUtils.processItems(nestHosts, this::processNestHost, executorService);
+ ThreadUtils.processItems(nestMembers, this::processNestMember, executorService);
+ }
+
+ private void processNestHost(DexProgramClass clazz) {
+ BooleanBox nestHasPrivateMembers =
+ new BooleanBox(IterableUtils.hasNext(clazz.members(DexEncodedMember::isPrivate)));
+ clazz
+ .getNestMembersClassAttributes()
+ .removeIf(
+ attribute -> {
+ DexProgramClass member =
+ asProgramClassOrNull(appView.definitionFor(attribute.getNestMember(), clazz));
+ if (member == null) {
+ return true;
+ }
+ nestHasPrivateMembers.computeIfNotSet(
+ () -> IterableUtils.hasNext(member.members(DexEncodedMember::isPrivate)));
+ return false;
+ });
+ if (nestHasPrivateMembers.isFalse() && appView.options().enableNestReduction) {
+ clazz.getNestMembersClassAttributes().clear();
}
- return false;
+ }
+
+ private void processNestMember(DexProgramClass clazz) {
+ DexProgramClass hostClass =
+ asProgramClassOrNull(appView.definitionFor(clazz.getNestHost(), clazz));
+ if (hostClass == null || !hostClass.isNestHost()) {
+ clazz.clearNestHost();
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index f673395..11b4ddf 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -955,7 +955,7 @@
return true;
}
if (arrayBaseType.isClassType()) {
- return arrayBaseType.asClassType().getInterfaces().size() == 0;
+ return arrayBaseType.asClassType().getInterfaces().isEmpty();
}
return false;
}
@@ -972,8 +972,8 @@
// have a common super interface nor are they implemented by a common superclass so the
// argument type of the outline will be java.lang.Object.
if (valueClassType.getClassType() == objectType
- && valueClassType.getInterfaces().size() == 1) {
- return valueClassType.getInterfaces().iterator().next();
+ && valueClassType.getInterfaces().hasSingleKnownInterface()) {
+ return valueClassType.getInterfaces().getSingleKnownInterface();
} else {
return valueClassType.getClassType();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
index 1694a7b..efc440b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
@@ -4,25 +4,15 @@
package com.android.tools.r8.ir.optimize;
-import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexProgramClass.ChecksumSupplier;
import com.android.tools.r8.graph.DexProto;
import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.MethodAccessFlags;
-import com.android.tools.r8.graph.MethodCollection;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.code.ConstClass;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -32,15 +22,13 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.conversion.MethodProcessingId;
import com.android.tools.r8.ir.desugar.ServiceLoaderSourceCode;
-import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
/**
* ServiceLoaderRewriter will attempt to rewrite calls on the form of: ServiceLoader.load(X.class,
@@ -71,19 +59,15 @@
*/
public class ServiceLoaderRewriter {
- public static final String SERVICE_LOADER_CLASS_NAME = "$$ServiceLoaderMethods";
- private static final String SERVICE_LOADER_METHOD_PREFIX_NAME = "$load";
-
- private AtomicReference<DexProgramClass> synthesizedClass = new AtomicReference<>();
-
private final AppView<AppInfoWithLiveness> appView;
+ private final List<ProgramMethod> serviceLoadMethods = new ArrayList<>();
public ServiceLoaderRewriter(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
}
- public DexProgramClass getSynthesizedClass() {
- return synthesizedClass.get();
+ public List<ProgramMethod> getServiceLoadMethods() {
+ return serviceLoadMethods;
}
public void rewrite(IRCode code, MethodProcessingId methodProcessingId) {
@@ -186,7 +170,7 @@
constClass.getValue(),
service -> {
DexEncodedMethod addedMethod =
- createSynthesizedMethod(service, classes, methodProcessingId);
+ createSynthesizedMethod(service, classes, methodProcessingId, code.context());
if (appView.options().isGeneratingClassFiles()) {
addedMethod.upgradeClassFileVersion(code.method().getClassFileVersion());
}
@@ -199,75 +183,31 @@
}
private DexEncodedMethod createSynthesizedMethod(
- DexType serviceType, List<DexClass> classes, MethodProcessingId methodProcessingId) {
- MethodCollection methodCollection = getOrSetSynthesizedClass().getMethodCollection();
- String methodNamePrefix = SERVICE_LOADER_METHOD_PREFIX_NAME + "$";
+ DexType serviceType,
+ List<DexClass> classes,
+ MethodProcessingId methodProcessingId,
+ ProgramMethod context) {
DexProto proto = appView.dexItemFactory().createProto(appView.dexItemFactory().iteratorType);
- synchronized (methodCollection) {
- DexMethod methodReference;
- do {
- methodReference =
- appView
- .dexItemFactory()
- .createMethod(
- appView.dexItemFactory().serviceLoaderRewrittenClassType,
- proto,
- methodNamePrefix + methodProcessingId.getAndIncrementId());
- } while (methodCollection.getMethod(methodReference) != null);
- DexEncodedMethod method =
- new DexEncodedMethod(
- methodReference,
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC, false),
- MethodTypeSignature.noSignature(),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- ServiceLoaderSourceCode.generate(serviceType, classes, appView.dexItemFactory()),
- true);
- methodCollection.addDirectMethod(method);
- return method;
+ ProgramMethod method =
+ appView
+ .getSyntheticItems()
+ .createMethod(
+ SyntheticKind.SERVICE_LOADER,
+ context,
+ appView.dexItemFactory(),
+ builder ->
+ builder
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setProto(proto)
+ .setCode(
+ m ->
+ ServiceLoaderSourceCode.generate(
+ serviceType, classes, appView.dexItemFactory())),
+ methodProcessingId);
+ synchronized (serviceLoadMethods) {
+ serviceLoadMethods.add(method);
}
- }
-
- private DexProgramClass getOrSetSynthesizedClass() {
- if (synthesizedClass.get() != null) {
- return synthesizedClass.get();
- }
- assert !appView.options().encodeChecksums;
- ChecksumSupplier checksumSupplier = DexProgramClass::invalidChecksumRequest;
- DexProgramClass clazz =
- synthesizedClass.updateAndGet(
- existingClass -> {
- if (existingClass != null) {
- return existingClass;
- }
- DexProgramClass newClass =
- new DexProgramClass(
- appView.dexItemFactory().serviceLoaderRewrittenClassType,
- null,
- new SynthesizedOrigin("Service Loader desugaring", getClass()),
- ClassAccessFlags.fromDexAccessFlags(
- Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
- appView.dexItemFactory().objectType,
- DexTypeList.empty(),
- appView.dexItemFactory().createString("ServiceLoader"),
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY, // Static fields.
- DexEncodedField.EMPTY_ARRAY, // Instance fields.
- DexEncodedMethod.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY, // Virtual methods.
- appView.dexItemFactory().getSkipNameValidationForTesting(),
- checksumSupplier);
- newClass.getMethodCollection().useSortedBacking();
- return newClass;
- });
- assert clazz != null;
- return clazz;
+ return method.getDefinition();
}
/**
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java b/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
index 1b55f13..9e360b4 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UtilityMethodsForCodeOptimizations.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize;
+import com.android.tools.r8.cf.CfVersion;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.DexItemFactory;
@@ -15,6 +16,7 @@
import com.android.tools.r8.ir.conversion.MethodProcessor;
import com.android.tools.r8.ir.optimize.templates.CfUtilityMethodsForCodeOptimizations;
import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.InternalOptions;
public class UtilityMethodsForCodeOptimizations {
@@ -22,22 +24,20 @@
public static UtilityMethodForCodeOptimizations synthesizeToStringIfNotNullMethod(
AppView<?> appView, ProgramMethod context, MethodProcessingId methodProcessingId) {
InternalOptions options = appView.options();
- if (options.isGeneratingClassFiles()) {
- // TODO(b/172194277): Allow synthetics when generating CF.
- return null;
- }
DexItemFactory dexItemFactory = appView.dexItemFactory();
DexProto proto = dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.objectType);
SyntheticItems syntheticItems = appView.getSyntheticItems();
ProgramMethod syntheticMethod =
syntheticItems.createMethod(
+ SyntheticNaming.SyntheticKind.TO_STRING_IF_NOT_NULL,
context,
dexItemFactory,
builder ->
builder
- .setProto(proto)
.setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
- .setCode(method -> getToStringIfNotNullCodeTemplate(method, options)),
+ .setClassFileVersion(CfVersion.V1_8)
+ .setCode(method -> getToStringIfNotNullCodeTemplate(method, options))
+ .setProto(proto),
methodProcessingId);
return new UtilityMethodForCodeOptimizations(syntheticMethod);
}
@@ -51,23 +51,21 @@
public static UtilityMethodForCodeOptimizations synthesizeThrowClassCastExceptionIfNotNullMethod(
AppView<?> appView, ProgramMethod context, MethodProcessingId methodProcessingId) {
InternalOptions options = appView.options();
- if (options.isGeneratingClassFiles()) {
- // TODO(b/172194277): Allow synthetics when generating CF.
- return null;
- }
DexItemFactory dexItemFactory = appView.dexItemFactory();
DexProto proto = dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.objectType);
SyntheticItems syntheticItems = appView.getSyntheticItems();
ProgramMethod syntheticMethod =
syntheticItems.createMethod(
+ SyntheticNaming.SyntheticKind.THROW_CCE_IF_NOT_NULL,
context,
dexItemFactory,
builder ->
builder
- .setProto(proto)
.setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setClassFileVersion(CfVersion.V1_8)
.setCode(
- method -> getThrowClassCastExceptionIfNotNullCodeTemplate(method, options)),
+ method -> getThrowClassCastExceptionIfNotNullCodeTemplate(method, options))
+ .setProto(proto),
methodProcessingId);
return new UtilityMethodForCodeOptimizations(syntheticMethod);
}
@@ -79,6 +77,62 @@
options, method);
}
+ public static UtilityMethodForCodeOptimizations synthesizeThrowIncompatibleClassChangeErrorMethod(
+ AppView<?> appView, ProgramMethod context, MethodProcessingId methodProcessingId) {
+ InternalOptions options = appView.options();
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexProto proto = dexItemFactory.createProto(dexItemFactory.icceType);
+ SyntheticItems syntheticItems = appView.getSyntheticItems();
+ ProgramMethod syntheticMethod =
+ syntheticItems.createMethod(
+ SyntheticNaming.SyntheticKind.THROW_ICCE,
+ context,
+ dexItemFactory,
+ builder ->
+ builder
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setClassFileVersion(CfVersion.V1_8)
+ .setCode(
+ method -> getThrowIncompatibleClassChangeErrorCodeTemplate(method, options))
+ .setProto(proto),
+ methodProcessingId);
+ return new UtilityMethodForCodeOptimizations(syntheticMethod);
+ }
+
+ private static CfCode getThrowIncompatibleClassChangeErrorCodeTemplate(
+ DexMethod method, InternalOptions options) {
+ return CfUtilityMethodsForCodeOptimizations
+ .CfUtilityMethodsForCodeOptimizationsTemplates_throwIncompatibleClassChangeError(
+ options, method);
+ }
+
+ public static UtilityMethodForCodeOptimizations synthesizeThrowNoSuchMethodErrorMethod(
+ AppView<?> appView, ProgramMethod context, MethodProcessingId methodProcessingId) {
+ InternalOptions options = appView.options();
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexProto proto = dexItemFactory.createProto(dexItemFactory.noSuchMethodErrorType);
+ SyntheticItems syntheticItems = appView.getSyntheticItems();
+ ProgramMethod syntheticMethod =
+ syntheticItems.createMethod(
+ SyntheticNaming.SyntheticKind.THROW_NSME,
+ context,
+ dexItemFactory,
+ builder ->
+ builder
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setClassFileVersion(CfVersion.V1_8)
+ .setCode(method -> getThrowNoSuchMethodErrorCodeTemplate(method, options))
+ .setProto(proto),
+ methodProcessingId);
+ return new UtilityMethodForCodeOptimizations(syntheticMethod);
+ }
+
+ private static CfCode getThrowNoSuchMethodErrorCodeTemplate(
+ DexMethod method, InternalOptions options) {
+ return CfUtilityMethodsForCodeOptimizations
+ .CfUtilityMethodsForCodeOptimizationsTemplates_throwNoSuchMethodError(options, method);
+ }
+
public static class UtilityMethodForCodeOptimizations {
private final ProgramMethod method;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index 5d79d0e..13865a0 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -223,7 +223,7 @@
// methods (which is bad for memory), or we would need to analyze the called methods
// before inlining them. The latter could be good solution, since we are going to build IR
// for the methods that need to be inlined anyway.
- assert appView.options().testing.allowClassInlinerGracefulExit;
+ assert false;
anyInlinedMethods = true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index 166022e..cf0ecb5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -491,34 +491,36 @@
// Step 1: We iterate over the field to find direct enum instance information and the values
// fields.
for (DexEncodedField staticField : enumClass.staticFields()) {
- if (EnumUnboxingCandidateAnalysis.isEnumField(staticField, enumClass.type)) {
+ if (factory.enumMembers.isEnumField(staticField, enumClass.type)) {
ObjectState enumState =
enumStaticFieldValues.getObjectStateForPossiblyPinnedField(staticField.field);
- if (enumState != null) {
- OptionalInt optionalOrdinal = getOrdinal(enumState);
- if (!optionalOrdinal.isPresent()) {
- return null;
+ if (enumState == null) {
+ if (!isFinalFieldInitialized(staticField, enumClass)) {
+ continue;
}
- int ordinal = optionalOrdinal.getAsInt();
- unboxedValues.put(staticField.field, ordinalToUnboxedInt(ordinal));
- ordinalToObjectState.put(ordinal, enumState);
- }
- } else if (EnumUnboxingCandidateAnalysis.matchesValuesField(
- staticField, enumClass.type, factory)) {
- AbstractValue valuesValue =
- enumStaticFieldValues.getValuesAbstractValueForPossiblyPinnedField(staticField.field);
- if (valuesValue == null || valuesValue.isZero()) {
- // Unused field
- continue;
- }
- if (valuesValue.isUnknown()) {
+ // Tracking the content of the field yielded either an empty object state, or something
+ // incoherent. We bail out.
return null;
}
- assert valuesValue.isSingleFieldValue();
- ObjectState valuesState = valuesValue.asSingleFieldValue().getState();
- if (!valuesState.isEnumValuesObjectState()) {
+ OptionalInt optionalOrdinal = getOrdinal(enumState);
+ if (!optionalOrdinal.isPresent()) {
return null;
}
+ int ordinal = optionalOrdinal.getAsInt();
+ unboxedValues.put(staticField.field, ordinalToUnboxedInt(ordinal));
+ ordinalToObjectState.put(ordinal, enumState);
+ } else if (factory.enumMembers.isValuesFieldCandidate(staticField, enumClass.type)) {
+ ObjectState valuesState =
+ enumStaticFieldValues.getObjectStateForPossiblyPinnedField(staticField.field);
+ if (valuesState == null) {
+ if (!isFinalFieldInitialized(staticField, enumClass)) {
+ continue;
+ }
+ // We could not track the content of that field, and the field could be a values field.
+ // We conservatively bail out.
+ return null;
+ }
+ assert valuesState.isEnumValuesObjectState();
assert valuesContents == null
|| valuesContents.equals(valuesState.asEnumValuesObjectState());
valuesContents = valuesState.asEnumValuesObjectState();
@@ -564,6 +566,13 @@
valuesContents == null ? EnumData.INVALID_VALUES_SIZE : valuesContents.getEnumValuesSize());
}
+ private boolean isFinalFieldInitialized(DexEncodedField staticField, DexProgramClass enumClass) {
+ assert staticField.isFinal();
+ return appView
+ .appInfo()
+ .isFieldOnlyWrittenInMethodIgnoringPinning(staticField, enumClass.getClassInitializer());
+ }
+
private EnumInstanceFieldData computeEnumFieldData(
DexField instanceField,
DexProgramClass enumClass,
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index 6c20c4f..4c7581e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -434,7 +434,7 @@
return factory.createField(
relocator.getNewMemberLocationFor(enumType),
factory.intArrayType,
- factory.enumValuesFieldName + "$field$" + compatibleName(enumType));
+ "$$values$$field$" + compatibleName(enumType));
}
private DexEncodedField computeValuesEncodedField(DexField field) {
@@ -451,7 +451,7 @@
return factory.createMethod(
relocator.getNewMemberLocationFor(enumType),
factory.createProto(factory.intArrayType),
- factory.enumValuesFieldName + "$method$" + compatibleName(enumType));
+ "$$values$$method$" + compatibleName(enumType));
}
private DexEncodedMethod computeValuesEncodedMethod(
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
index f2f70ca..10a50ca 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
@@ -120,9 +120,9 @@
}
private DexEncodedMethod fixupEncodedMethod(DexEncodedMethod method) {
- DexProto oldProto = method.proto();
+ DexProto oldProto = method.getProto();
DexProto newProto = fixupProto(oldProto);
- if (newProto == method.proto()) {
+ if (newProto == method.getProto()) {
return method;
}
assert !method.isClassInitializer();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index b5dfee6..9868a64 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -1090,10 +1090,18 @@
} else if (classInitializerSideEffect.canBePostponed()) {
feedback.classInitializerMayBePostponed(method);
} else {
- assert !context.getHolderType().isD8R8SynthesizedLambdaClassType()
- || options.debug
- || appView.appInfo().hasPinnedInstanceInitializer(context.getHolderType())
- || appView.options().horizontalClassMergerOptions().isJavaLambdaMergingEnabled()
+ assert options.debug
+ || appView
+ .getSyntheticItems()
+ .verifySyntheticLambdaProperty(
+ context.getHolder(),
+ lambdaClass ->
+ appView.appInfo().hasPinnedInstanceInitializer(lambdaClass.getType())
+ || appView
+ .options()
+ .horizontalClassMergerOptions()
+ .isJavaLambdaMergingEnabled(),
+ nonLambdaClass -> true)
: "Unexpected observable side effects from lambda `" + context.toSourceString() + "`";
}
return;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index 89ffafd..e9ff9e8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -50,6 +50,7 @@
import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.ProguardConfiguration;
import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.ThreadUtils;
@@ -397,20 +398,30 @@
for (LambdaGroup group : groups.values()) {
ThrowingConsumer<DexClass, LambdaStructureError> validator =
group.lambdaClassValidator(kotlin, appView.appInfo());
- group.forEachLambda(info ->
- futures.add(service.submit(() -> {
- try {
- validator.accept(info.clazz);
- } catch (LambdaStructureError error) {
- if (error.reportable) {
- reporter.info(
- new StringDiagnostic("Unexpected Kotlin lambda structure [" +
- info.clazz.type.toSourceString() + "]: " + error.getMessage())
- );
- }
- invalidateLambda(info.clazz.type);
- }
- })));
+ group.forEachLambda(
+ info ->
+ futures.add(
+ service.submit(
+ () -> {
+ try {
+ validator.accept(info.clazz);
+ } catch (LambdaStructureError error) {
+ ProguardConfiguration proguardConfiguration =
+ appView.options().getProguardConfiguration();
+ if (error.reportable
+ && !proguardConfiguration
+ .getDontNotePatterns()
+ .matches(info.clazz.getType())) {
+ reporter.info(
+ new StringDiagnostic(
+ "Unexpected Kotlin lambda structure ["
+ + info.clazz.type.toSourceString()
+ + "]: "
+ + error.getMessage()));
+ }
+ invalidateLambda(info.clazz.type);
+ }
+ })));
}
ThreadUtils.awaitFutures(futures);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/StringBuilderMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/StringBuilderMethodOptimizer.java
index 99b1bda..d75e060 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/StringBuilderMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/StringBuilderMethodOptimizer.java
@@ -122,16 +122,13 @@
UtilityMethodForCodeOptimizations toStringIfNotNullMethod =
UtilityMethodsForCodeOptimizations.synthesizeToStringIfNotNullMethod(
appView, code.context(), state.methodProcessingId);
- // TODO(b/172194277): Allow synthetics when generating CF.
- if (toStringIfNotNullMethod != null) {
- toStringIfNotNullMethod.optimize(state.methodProcessor);
- InvokeStatic replacement =
- InvokeStatic.builder()
- .setMethod(toStringIfNotNullMethod.getMethod())
- .setSingleArgument(object)
- .build();
- instructionIterator.replaceCurrentInstruction(replacement);
- }
+ toStringIfNotNullMethod.optimize(state.methodProcessor);
+ InvokeStatic replacement =
+ InvokeStatic.builder()
+ .setMethod(toStringIfNotNullMethod.getMethod())
+ .setSingleArgument(object)
+ .build();
+ instructionIterator.replaceCurrentInstruction(replacement);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfo.java
new file mode 100644
index 0000000..a704abb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfo.java
@@ -0,0 +1,67 @@
+// 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.ir.optimize.membervaluepropagation.assume;
+
+import com.android.tools.r8.shaking.ProguardMemberRule;
+import com.android.tools.r8.shaking.ProguardMemberRuleReturnValue;
+
+public class AssumeInfo {
+
+ public enum AssumeType {
+ ASSUME_NO_SIDE_EFFECTS,
+ ASSUME_VALUES;
+
+ AssumeType meet(AssumeType type) {
+ return this == ASSUME_NO_SIDE_EFFECTS || type == ASSUME_NO_SIDE_EFFECTS
+ ? ASSUME_NO_SIDE_EFFECTS
+ : ASSUME_VALUES;
+ }
+ }
+
+ private final AssumeType type;
+ private final ProguardMemberRule rule;
+
+ public AssumeInfo(AssumeType type, ProguardMemberRule rule) {
+ this.type = type;
+ this.rule = rule;
+ }
+
+ public boolean hasReturnInfo() {
+ return rule.hasReturnValue();
+ }
+
+ public ProguardMemberRuleReturnValue getReturnInfo() {
+ return rule.getReturnValue();
+ }
+
+ public boolean isAssumeNoSideEffects() {
+ return type == AssumeType.ASSUME_NO_SIDE_EFFECTS;
+ }
+
+ public boolean isAssumeValues() {
+ return type == AssumeType.ASSUME_VALUES;
+ }
+
+ public AssumeInfo meet(AssumeInfo lookup) {
+ return new AssumeInfo(type.meet(lookup.type), rule.hasReturnValue() ? rule : lookup.rule);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other == null) {
+ return false;
+ }
+ if (!(other instanceof AssumeInfo)) {
+ return false;
+ }
+ AssumeInfo assumeInfo = (AssumeInfo) other;
+ return type == assumeInfo.type && rule == assumeInfo.rule;
+ }
+
+ @Override
+ public int hashCode() {
+ return type.ordinal() * 31 + rule.hashCode();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfoLookup.java b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfoLookup.java
new file mode 100644
index 0000000..5ddba94
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/assume/AssumeInfoLookup.java
@@ -0,0 +1,51 @@
+// 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.ir.optimize.membervaluepropagation.assume;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndMember;
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexMember;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfo.AssumeType;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.ProguardMemberRule;
+
+public class AssumeInfoLookup {
+
+ public static AssumeInfo lookupAssumeInfo(
+ AppView<AppInfoWithLiveness> appView,
+ SingleResolutionResult resolutionResult,
+ DexClassAndMethod singleTarget) {
+ AssumeInfo resolutionLookup = lookupAssumeInfo(appView, resolutionResult.getResolutionPair());
+ if (resolutionLookup == null) {
+ return singleTarget != null ? lookupAssumeInfo(appView, singleTarget) : null;
+ }
+ AssumeInfo singleTargetLookup =
+ singleTarget != null ? lookupAssumeInfo(appView, singleTarget) : null;
+ return singleTargetLookup != null
+ ? resolutionLookup.meet(singleTargetLookup)
+ : resolutionLookup;
+ }
+
+ public static AssumeInfo lookupAssumeInfo(
+ AppView<AppInfoWithLiveness> appView, DexClassAndMember<?, ?> member) {
+ DexMember<?, ?> reference = member.getReference();
+ ProguardMemberRule assumeNoSideEffectsRule = appView.appInfo().noSideEffects.get(reference);
+ ProguardMemberRule assumeValuesRule = appView.appInfo().assumedValues.get(reference);
+ if (assumeNoSideEffectsRule == null && assumeValuesRule == null) {
+ return null;
+ }
+ AssumeType type =
+ assumeNoSideEffectsRule != null
+ ? AssumeType.ASSUME_NO_SIDE_EFFECTS
+ : AssumeType.ASSUME_VALUES;
+ if ((assumeNoSideEffectsRule != null && assumeNoSideEffectsRule.hasReturnValue())
+ || assumeValuesRule == null) {
+ return new AssumeInfo(type, assumeNoSideEffectsRule);
+ }
+ return new AssumeInfo(type, assumeValuesRule);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeLayout.java b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeLayout.java
index 6e36d48..86958a5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeLayout.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeLayout.java
@@ -35,9 +35,9 @@
public Match test(InstructionListIterator it) {
if (backwards) {
- return testDirection(() -> it.hasPrevious(), () -> it.previous(), () -> it.next());
+ return testDirection(it::hasPrevious, it::previous, it::next);
} else {
- return testDirection(() -> it.hasNext(), () -> it.next(), () -> it.previous());
+ return testDirection(it::hasNext, it::next, it::previous);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizations.java b/src/main/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizations.java
index 9625b93..831a0b3 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizations.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizations.java
@@ -33,6 +33,8 @@
public static void registerSynthesizedCodeReferences(DexItemFactory factory) {
factory.createSynthesizedType("Ljava/lang/ClassCastException;");
+ factory.createSynthesizedType("Ljava/lang/IncompatibleClassChangeError;");
+ factory.createSynthesizedType("Ljava/lang/NoSuchMethodError;");
}
public static CfCode
@@ -73,6 +75,53 @@
ImmutableList.of());
}
+ public static CfCode
+ CfUtilityMethodsForCodeOptimizationsTemplates_throwIncompatibleClassChangeError(
+ InternalOptions options, DexMethod method) {
+ CfLabel label0 = new CfLabel();
+ return new CfCode(
+ method.holder,
+ 2,
+ 0,
+ ImmutableList.of(
+ label0,
+ new CfNew(options.itemFactory.createType("Ljava/lang/IncompatibleClassChangeError;")),
+ new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+ new CfInvoke(
+ 183,
+ options.itemFactory.createMethod(
+ options.itemFactory.createType("Ljava/lang/IncompatibleClassChangeError;"),
+ options.itemFactory.createProto(options.itemFactory.voidType),
+ options.itemFactory.createString("<init>")),
+ false),
+ new CfThrow()),
+ ImmutableList.of(),
+ ImmutableList.of());
+ }
+
+ public static CfCode CfUtilityMethodsForCodeOptimizationsTemplates_throwNoSuchMethodError(
+ InternalOptions options, DexMethod method) {
+ CfLabel label0 = new CfLabel();
+ return new CfCode(
+ method.holder,
+ 2,
+ 0,
+ ImmutableList.of(
+ label0,
+ new CfNew(options.itemFactory.createType("Ljava/lang/NoSuchMethodError;")),
+ new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+ new CfInvoke(
+ 183,
+ options.itemFactory.createMethod(
+ options.itemFactory.createType("Ljava/lang/NoSuchMethodError;"),
+ options.itemFactory.createProto(options.itemFactory.voidType),
+ options.itemFactory.createString("<init>")),
+ false),
+ new CfThrow()),
+ ImmutableList.of(),
+ ImmutableList.of());
+ }
+
public static CfCode CfUtilityMethodsForCodeOptimizationsTemplates_toStringIfNotNull(
InternalOptions options, DexMethod method) {
CfLabel label0 = new CfLabel();
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorBuilder.java b/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorBuilder.java
new file mode 100644
index 0000000..b02544d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorBuilder.java
@@ -0,0 +1,134 @@
+// 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.ir.synthetic;
+
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.DexClassAndField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.OptionalBool;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import java.util.function.Consumer;
+import org.objectweb.asm.Opcodes;
+
+public class FieldAccessorBuilder {
+
+ private DexField field;
+ private OptionalBool isInstanceField = OptionalBool.unknown();
+ private OptionalBool isSetter = OptionalBool.unknown();
+ private DexMethod sourceMethod;
+
+ private FieldAccessorBuilder() {}
+
+ public static FieldAccessorBuilder builder() {
+ return new FieldAccessorBuilder();
+ }
+
+ public FieldAccessorBuilder apply(Consumer<FieldAccessorBuilder> consumer) {
+ consumer.accept(this);
+ return this;
+ }
+
+ public FieldAccessorBuilder setField(DexClassAndField field) {
+ return field.getAccessFlags().isStatic()
+ ? setStaticField(field.getReference())
+ : setInstanceField(field.getReference());
+ }
+
+ public FieldAccessorBuilder setGetter() {
+ isSetter = OptionalBool.FALSE;
+ return this;
+ }
+
+ public FieldAccessorBuilder setInstanceField(DexField field) {
+ this.field = field;
+ this.isInstanceField = OptionalBool.TRUE;
+ return this;
+ }
+
+ public FieldAccessorBuilder setSetter() {
+ isSetter = OptionalBool.TRUE;
+ return this;
+ }
+
+ public FieldAccessorBuilder setSourceMethod(DexMethod sourceMethod) {
+ this.sourceMethod = sourceMethod;
+ return this;
+ }
+
+ public FieldAccessorBuilder setStaticField(DexField field) {
+ this.field = field;
+ this.isInstanceField = OptionalBool.FALSE;
+ return this;
+ }
+
+ public CfCode build() {
+ assert validate();
+ int maxStack = 0;
+ int maxLocals = 0;
+ Builder<CfInstruction> instructions = ImmutableList.builder();
+ if (isInstanceField()) {
+ // Load the receiver.
+ instructions.add(new CfLoad(ValueType.OBJECT, maxLocals));
+ maxStack += 1;
+ maxLocals += 1;
+ }
+
+ if (isSetter()) {
+ // Load the argument.
+ ValueType fieldType = ValueType.fromDexType(field.getType());
+ instructions.add(new CfLoad(fieldType, maxLocals));
+ maxLocals += fieldType.requiredRegisters();
+ }
+
+ // Get or set the field.
+ int opcode =
+ Opcodes.GETSTATIC + BooleanUtils.intValue(isSetter()) + (isInstanceField.ordinal() << 1);
+ instructions.add(new CfFieldInstruction(opcode, field, field));
+
+ // Return.
+ if (isSetter()) {
+ instructions.add(new CfReturnVoid());
+ } else {
+ ValueType fieldType = ValueType.fromDexType(field.getType());
+ instructions.add(new CfReturn(fieldType));
+ }
+
+ ImmutableList<CfTryCatch> tryCatchRanges = ImmutableList.of();
+ ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+ return new CfCode(
+ sourceMethod.getHolderType(),
+ maxStack,
+ maxLocals,
+ instructions.build(),
+ tryCatchRanges,
+ localVariables);
+ }
+
+ private boolean isSetter() {
+ return isSetter.isTrue();
+ }
+
+ private boolean isInstanceField() {
+ return isInstanceField.isTrue();
+ }
+
+ private boolean validate() {
+ assert field != null;
+ assert !isInstanceField.isUnknown();
+ assert !isSetter.isUnknown();
+ assert sourceMethod != null;
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorSourceCode.java b/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorSourceCode.java
deleted file mode 100644
index 8936c73..0000000
--- a/src/main/java/com/android/tools/r8/ir/synthetic/FieldAccessorSourceCode.java
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.synthetic;
-
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring.DexFieldWithAccess;
-
-// Source code representing simple forwarding method.
-public final class FieldAccessorSourceCode extends SyntheticSourceCode {
-
- private final DexFieldWithAccess fieldWithAccess;
-
- public FieldAccessorSourceCode(
- DexType receiver,
- DexMethod method,
- Position callerPosition,
- DexMethod originalMethod,
- DexFieldWithAccess field) {
- super(receiver, method, callerPosition, originalMethod);
- this.fieldWithAccess = field;
- assert method.proto.returnType == fieldWithAccess.getType() || fieldWithAccess.isPut();
- }
-
- @Override
- protected void prepareInstructions() {
- if (fieldWithAccess.isInstanceGet()) {
- ValueType valueType = ValueType.fromDexType(proto.returnType);
- int objReg = getParamRegister(0);
- int returnReg = nextRegister(valueType);
- add(builder -> builder.addInstanceGet(returnReg, objReg, fieldWithAccess.getField()));
- add(builder -> builder.addReturn(returnReg));
- } else if (fieldWithAccess.isStaticGet()) {
- ValueType valueType = ValueType.fromDexType(proto.returnType);
- int returnReg = nextRegister(valueType);
- add(builder -> builder.addStaticGet(returnReg, fieldWithAccess.getField()));
- add(builder -> builder.addReturn(returnReg));
- } else if (fieldWithAccess.isInstancePut()) {
- int objReg = getParamRegister(0);
- int putValueReg = getParamRegister(1);
- add(builder -> builder.addInstancePut(putValueReg, objReg, fieldWithAccess.getField()));
- add(IRBuilder::addReturn);
- } else {
- assert fieldWithAccess.isStaticPut();
- int putValueReg = getParamRegister(0);
- add(builder -> builder.addStaticPut(putValueReg, fieldWithAccess.getField()));
- add(IRBuilder::addReturn);
- }
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
index 8d8ca9f..794fd3e 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
@@ -20,8 +20,10 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
+import java.util.function.Consumer;
import org.objectweb.asm.Opcodes;
public class ForwardMethodBuilder {
@@ -41,6 +43,7 @@
private DexMethod sourceMethod = null;
private DexMethod targetMethod = null;
+ private boolean sourceMethodHasExtraUnusedParameter = false;
private boolean staticSource = false;
private InvokeType invokeType = null;
@@ -53,12 +56,24 @@
this.factory = factory;
}
+ public ForwardMethodBuilder apply(Consumer<ForwardMethodBuilder> fn) {
+ fn.accept(this);
+ return this;
+ }
+
public ForwardMethodBuilder setNonStaticSource(DexMethod method) {
sourceMethod = method;
staticSource = false;
return this;
}
+ public ForwardMethodBuilder setNonStaticSourceWithExtraUnusedParameter(DexMethod method) {
+ sourceMethod = method;
+ staticSource = false;
+ sourceMethodHasExtraUnusedParameter = true;
+ return this;
+ }
+
public ForwardMethodBuilder setStaticSource(DexMethod method) {
sourceMethod = method;
staticSource = true;
@@ -79,6 +94,10 @@
return this;
}
+ public ForwardMethodBuilder setConstructorTarget(DexMethod method) {
+ return setDirectTarget(method, false);
+ }
+
public ForwardMethodBuilder setDirectTarget(DexMethod method, boolean isInterface) {
targetMethod = method;
invokeType = InvokeType.SPECIAL;
@@ -126,7 +145,9 @@
maxLocals += 1;
}
DexType[] sourceParameters = getSourceParameters();
- for (int i = 0; i < sourceParameters.length; i++) {
+ for (int i = 0;
+ i < sourceParameters.length - BooleanUtils.intValue(sourceMethodHasExtraUnusedParameter);
+ i++) {
DexType parameter = sourceParameters[i];
ValueType parameterType = ValueType.fromDexType(parameter);
instructions.add(new CfLoad(parameterType, maxLocals));
@@ -212,7 +233,9 @@
}
private int sourceArguments() {
- return sourceMethod.getParameters().size() + (isStaticSource() ? 0 : 1);
+ return sourceMethod.getParameters().size()
+ + (isStaticSource() ? 0 : 1)
+ - BooleanUtils.intValue(sourceMethodHasExtraUnusedParameter);
}
private int targetArguments() {
diff --git a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
index ef724ec..cf6a117 100644
--- a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
@@ -40,7 +40,7 @@
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.naming.ProguardMapSupplier;
import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.AsmUtils;
import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -124,7 +124,7 @@
marker.isRelocator() ? Optional.empty() : Optional.of(marker.toString());
LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(appView);
for (DexProgramClass clazz : application.classes()) {
- assert SyntheticItems.verifyNotInternalSynthetic(clazz.getType());
+ assert SyntheticNaming.verifyNotInternalSynthetic(clazz.getType());
try {
writeClass(clazz, consumer, rewriter, markerString);
} catch (ClassTooLargeException e) {
@@ -194,6 +194,7 @@
for (int i = 0; i < clazz.interfaces.values.length; i++) {
interfaces[i] = namingLens.lookupInternalName(clazz.interfaces.values[i]);
}
+ assert SyntheticNaming.verifyNotInternalSynthetic(name);
writer.visit(version.raw(), access, name, signature, superName, interfaces);
writeAnnotations(writer::visitAnnotation, clazz.annotations().annotations);
ImmutableMap<DexString, DexValue> defaults = getAnnotationDefaults(clazz.annotations());
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
index e7ca5b5..771c336 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
@@ -100,13 +100,6 @@
}
ClassRenaming computeRenaming(Timing timing) {
- return computeRenaming(timing, Collections.emptyMap());
- }
-
- ClassRenaming computeRenaming(Timing timing, Map<DexType, DexString> syntheticClasses) {
- // Externally defined synthetic classes populate an initial renaming.
- renaming.putAll(syntheticClasses);
-
// Collect names we have to keep.
timing.begin("reserve");
for (DexClass clazz : classes) {
diff --git a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
index a8bd96c..0f5924d 100644
--- a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
@@ -23,7 +23,6 @@
import com.google.common.collect.Sets;
import java.io.PrintStream;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
@@ -397,7 +396,7 @@
return Comparator.comparing(globalStateMap::get);
}
- private void reserveNamesInInterfaces(Collection<DexClass> interfaces) {
+ private void reserveNamesInInterfaces(Iterable<DexClass> interfaces) {
for (DexClass iface : interfaces) {
assert iface.isInterface();
minifierState.allocateReservationStateAndReserve(iface.type, iface.type);
@@ -407,7 +406,7 @@
}
}
- void assignNamesToInterfaceMethods(Timing timing, Collection<DexClass> interfaces) {
+ void assignNamesToInterfaceMethods(Timing timing, Iterable<DexClass> interfaces) {
timing.begin("Interface minification");
// Reserve all the names that are required for interfaces.
timing.begin("Reserve direct and compute hierarchy");
@@ -643,19 +642,26 @@
clazz -> {
// TODO(b/133091438): Extend the if check to test for !clazz.isLibrary().
if (!clazz.isInterface()) {
- for (DexType directlyImplemented :
- appView.appInfo().implementedInterfaces(clazz.type)) {
- InterfaceReservationState iState = interfaceStateMap.get(directlyImplemented);
- if (iState != null) {
- DexType frontierType = minifierState.getFrontier(clazz.type);
- iState.addReservationType(frontierType);
- // The reservation state should already be added, but if a class is extending
- // an interface, we will not visit the class during the sub-type traversel
- if (minifierState.getReservationState(clazz.type) == null) {
- minifierState.allocateReservationStateAndReserve(clazz.type, frontierType);
- }
- }
- }
+ appView
+ .appInfo()
+ .implementedInterfaces(clazz.type)
+ .forEach(
+ (directlyImplemented, ignoreIsKnownAndReserveInAllCases) -> {
+ InterfaceReservationState iState =
+ interfaceStateMap.get(directlyImplemented);
+ if (iState != null) {
+ DexType frontierType = minifierState.getFrontier(clazz.type);
+ iState.addReservationType(frontierType);
+ // The reservation state should already be added, but if a class is
+ // extending
+ // an interface, we will not visit the class during the sub-type
+ // traversel
+ if (minifierState.getReservationState(clazz.type) == null) {
+ minifierState.allocateReservationStateAndReserve(
+ clazz.type, frontierType);
+ }
+ }
+ });
}
});
}
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
index 49dcd83..0f50ecb 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -16,7 +16,6 @@
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableMap;
-import java.util.Collection;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
@@ -174,7 +173,7 @@
}
}
- MethodRenaming computeRenaming(Collection<DexClass> interfaces, Timing timing) {
+ MethodRenaming computeRenaming(Iterable<DexClass> interfaces, Timing timing) {
// Phase 1: Reserve all the names that need to be kept and allocate linked state in the
// library part.
timing.begin("Phase 1");
diff --git a/src/main/java/com/android/tools/r8/naming/Minifier.java b/src/main/java/com/android/tools/r8/naming/Minifier.java
index 4bc638a..c00993f 100644
--- a/src/main/java/com/android/tools/r8/naming/Minifier.java
+++ b/src/main/java/com/android/tools/r8/naming/Minifier.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming;
+import static com.android.tools.r8.graph.DexApplication.classesWithDeterministicOrder;
import static com.android.tools.r8.utils.StringUtils.EMPTY_CHAR_ARRAY;
import static com.android.tools.r8.utils.SymbolGenerationUtils.PRIMITIVE_TYPE_NAMES;
@@ -26,11 +27,10 @@
import com.android.tools.r8.utils.SymbolGenerationUtils;
import com.android.tools.r8.utils.SymbolGenerationUtils.MixedCasing;
import com.android.tools.r8.utils.Timing;
-import java.util.Comparator;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import java.util.TreeSet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.function.BiPredicate;
@@ -48,8 +48,7 @@
assert appView.options().isMinifying();
SubtypingInfo subtypingInfo = appView.appInfo().computeSubtypingInfo();
timing.begin("ComputeInterfaces");
- Set<DexClass> interfaces = new TreeSet<>(Comparator.comparing(a -> a.type));
- interfaces.addAll(appView.appInfo().computeReachableInterfaces());
+ List<DexClass> interfaces = computeReachableInterfacesWithDeterministicOrder();
timing.end();
timing.begin("MinifyClasses");
ClassNameMinifier classNameMinifier =
@@ -92,6 +91,12 @@
return lens;
}
+ private List<DexClass> computeReachableInterfacesWithDeterministicOrder() {
+ List<DexClass> interfaces = new ArrayList<>();
+ appView.appInfo().forEachReachableInterface(interfaces::add);
+ return classesWithDeterministicOrder(interfaces);
+ }
+
abstract static class BaseMinificationNamingStrategy {
// We have to ensure that the names proposed by the minifier is not used in the obfuscation
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
index 6d8c889..b75956e 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.naming;
+import static com.android.tools.r8.graph.DexApplication.classesWithDeterministicOrder;
+
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
@@ -35,7 +37,9 @@
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.util.ArrayDeque;
+import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
@@ -73,9 +77,8 @@
private final SeedMapper seedMapper;
private final BiMap<DexType, DexString> mappedNames = HashBiMap.create();
// To keep the order deterministic, we sort the classes by their type, which is a unique key.
- private final Set<DexClass> mappedClasses = new TreeSet<>((a, b) -> a.type.compareTo(b.type));
+ private final Set<DexClass> mappedClasses = Sets.newIdentityHashSet();
private final Map<DexReference, MemberNaming> memberNames = Maps.newIdentityHashMap();
- private final Map<DexType, DexString> syntheticCompanionClasses = Maps.newIdentityHashMap();
private final Map<DexMethod, DexString> defaultInterfaceMethodImplementationNames =
Maps.newIdentityHashMap();
private final Map<DexMethod, DexString> additionalMethodNamings = Maps.newIdentityHashMap();
@@ -95,15 +98,15 @@
Set<DexReference> notMappedReferences = new HashSet<>();
timing.begin("MappingInterfaces");
- Set<DexClass> interfaces = new TreeSet<>((a, b) -> a.type.compareTo(b.type));
+ Set<DexClass> interfaces = new TreeSet<>(Comparator.comparing(DexClass::getType));
Consumer<DexClass> consumer =
- dexClass -> {
- if (dexClass.isInterface()) {
+ clazz -> {
+ if (clazz.isInterface()) {
// Only visit top level interfaces because computeMapping will visit the hierarchy.
- if (dexClass.interfaces.isEmpty()) {
- computeMapping(dexClass.type, nonPrivateMembers, notMappedReferences, subtypingInfo);
+ if (clazz.interfaces.isEmpty()) {
+ computeMapping(clazz.type, nonPrivateMembers, notMappedReferences, subtypingInfo);
}
- interfaces.add(dexClass);
+ interfaces.add(clazz);
}
};
// For union-find of interface methods we also need to add the library types above live types.
@@ -141,9 +144,8 @@
// in the ClassNameMinifier that the strategy should produce a "fresh" name so we just
// use the existing strategy.
new MinificationPackageNamingStrategy(appView),
- mappedClasses);
- ClassRenaming classRenaming =
- classNameMinifier.computeRenaming(timing, syntheticCompanionClasses);
+ classesWithDeterministicOrder(mappedClasses));
+ ClassRenaming classRenaming = classNameMinifier.computeRenaming(timing);
timing.end();
ApplyMappingMemberNamingStrategy nameStrategy =
@@ -341,11 +343,10 @@
}
// TODO(b/150736225): Is this sound? What if the type is a library type that has been pruned?
DexClass dexClass = appView.appInfo().definitionForWithoutExistenceAssert(type);
- if (dexClass == null) {
+ if (dexClass == null || dexClass.isClasspathClass()) {
computeDefaultInterfaceMethodMappingsForType(
type,
classNaming,
- syntheticCompanionClasses,
defaultInterfaceMethodImplementationNames);
}
}
@@ -354,7 +355,6 @@
private void computeDefaultInterfaceMethodMappingsForType(
DexType type,
ClassNamingForMapApplier classNaming,
- Map<DexType, DexString> syntheticCompanionClasses,
Map<DexMethod, DexString> defaultInterfaceMethodImplementationNames) {
// If the class does not resolve, then check if it is a companion class for an interface on
// the class path.
@@ -366,7 +366,6 @@
if (interfaceType == null || !interfaceType.isClasspathClass()) {
return;
}
- syntheticCompanionClasses.put(type, factory.createString(classNaming.renamedName));
for (List<MemberNaming> namings : classNaming.getQualifiedMethodMembers().values()) {
// If the qualified name has been mapped to multiple names we can't compute a mapping (and it
// should not be possible that this is a default interface method in that case.)
diff --git a/src/main/java/com/android/tools/r8/optimize/ClassAndMemberPublicizer.java b/src/main/java/com/android/tools/r8/optimize/ClassAndMemberPublicizer.java
index 30d9b7d..a675776 100644
--- a/src/main/java/com/android/tools/r8/optimize/ClassAndMemberPublicizer.java
+++ b/src/main/java/com/android/tools/r8/optimize/ClassAndMemberPublicizer.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
@@ -83,9 +82,7 @@
// Phase 2: Visit classes and promote class/member to public if possible.
timing.begin("Phase 2: promoteToPublic");
- for (DexClass iface : appView.appInfo().computeReachableInterfaces()) {
- publicizeType(iface.type);
- }
+ appView.appInfo().forEachReachableInterface(clazz -> publicizeType(clazz.getType()));
publicizeType(appView.dexItemFactory().objectType);
timing.end();
diff --git a/src/main/java/com/android/tools/r8/repackaging/Repackaging.java b/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
index 51e419b..eba0a87 100644
--- a/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
+++ b/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
@@ -8,7 +8,6 @@
import static com.android.tools.r8.utils.DescriptorUtils.DESCRIPTOR_PACKAGE_SEPARATOR;
import static com.android.tools.r8.utils.DescriptorUtils.INNER_CLASS_SEPARATOR;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
@@ -73,8 +72,7 @@
return lens;
}
- public static boolean verifyIdentityRepackaging(
- AppView<? extends AppInfoWithClassHierarchy> appView) {
+ public static boolean verifyIdentityRepackaging(AppView<AppInfoWithLiveness> appView) {
// Running the tree fixer with an identity mapping helps ensure that the fixup of of items is
// complete as the rewrite replaces all items regardless of repackaging.
// The identity mapping should result in no move callbacks being called.
@@ -140,10 +138,11 @@
return null;
}
RepackagingLens.Builder lensBuilder = new RepackagingLens.Builder();
+ RepackagingTreeFixer repackagingTreeFixer =
+ new RepackagingTreeFixer(appView, mappings, lensBuilder);
List<DexProgramClass> newProgramClasses =
new ArrayList<>(
- new RepackagingTreeFixer(appView, mappings, lensBuilder)
- .fixupClasses(appView.appInfo().classesWithDeterministicOrder()));
+ repackagingTreeFixer.fixupClasses(appView.appInfo().classesWithDeterministicOrder()));
appBuilder.replaceProgramClasses(newProgramClasses);
RepackagingLens lens = lensBuilder.build(appView);
new AnnotationFixer(lens).run(appBuilder.getProgramClasses());
@@ -156,10 +155,14 @@
private final Builder lensBuilder;
public RepackagingTreeFixer(
- AppView<?> appView, BiMap<DexType, DexType> mappings, Builder lensBuilder) {
+ AppView<AppInfoWithLiveness> appView,
+ BiMap<DexType, DexType> mappings,
+ Builder lensBuilder) {
super(appView);
+ assert mappings != null;
this.mappings = mappings;
this.lensBuilder = lensBuilder;
+ recordFailedResolutionChanges();
}
@Override
diff --git a/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
index f0ba88d..6decd5e 100644
--- a/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
+++ b/src/main/java/com/android/tools/r8/retrace/internal/StackTraceElementStringProxy.java
@@ -15,7 +15,6 @@
import com.android.tools.r8.retrace.RetracedType;
import com.android.tools.r8.retrace.StackTraceElementProxy;
import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.StringUtils.BraceType;
import com.android.tools.r8.utils.TriFunction;
import java.util.ArrayList;
import java.util.List;
@@ -287,7 +286,7 @@
return original.getMethodArguments();
}
return StringUtils.join(
- retraced.getMethodArguments(), ",", BraceType.NONE, RetracedType::getTypeName);
+ ",", retraced.getMethodArguments(), RetracedType::getTypeName);
});
orderedIndices.add(methodArguments);
return this;
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 6b316f7..363cb30 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -45,9 +45,9 @@
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.code.Invoke.Type;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
import com.android.tools.r8.synthesis.CommittedItems;
import com.android.tools.r8.utils.CollectionUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -89,8 +89,11 @@
*/
private final Set<DexMethod> targetedMethods;
- /** Set of targets that lead to resolution errors, such as non-existing or invalid targets. */
- private final Set<DexMethod> failedResolutionTargets;
+ /** Method targets that lead to resolution errors such as non-existing or invalid targets. */
+ private final Set<DexMethod> failedMethodResolutionTargets;
+
+ /** Field targets that lead to resolution errors, such as non-existing or invalid targets. */
+ private final Set<DexField> failedFieldResolutionTargets;
/**
* Set of program methods that are used as the bootstrap method for an invoke-dynamic instruction.
@@ -197,7 +200,8 @@
MissingClasses missingClasses,
Set<DexType> liveTypes,
Set<DexMethod> targetedMethods,
- Set<DexMethod> failedResolutionTargets,
+ Set<DexMethod> failedMethodResolutionTargets,
+ Set<DexField> failedFieldResolutionTargets,
Set<DexMethod> bootstrapMethods,
Set<DexMethod> methodsTargetedByInvokeDynamic,
Set<DexMethod> virtualMethodsTargetedByInvokeDirect,
@@ -235,7 +239,8 @@
this.deadProtoTypes = deadProtoTypes;
this.liveTypes = liveTypes;
this.targetedMethods = targetedMethods;
- this.failedResolutionTargets = failedResolutionTargets;
+ this.failedMethodResolutionTargets = failedMethodResolutionTargets;
+ this.failedFieldResolutionTargets = failedFieldResolutionTargets;
this.bootstrapMethods = bootstrapMethods;
this.methodsTargetedByInvokeDynamic = methodsTargetedByInvokeDynamic;
this.virtualMethodsTargetedByInvokeDirect = virtualMethodsTargetedByInvokeDirect;
@@ -269,7 +274,7 @@
this.switchMaps = switchMaps;
this.lockCandidates = lockCandidates;
this.initClassReferences = initClassReferences;
- verify();
+ assert verify();
}
private AppInfoWithLiveness(AppInfoWithLiveness previous, CommittedItems committedItems) {
@@ -279,9 +284,10 @@
previous.getMainDexClasses(),
previous.deadProtoTypes,
previous.getMissingClasses(),
- CollectionUtils.mergeSets(previous.liveTypes, committedItems.getCommittedTypes()),
+ CollectionUtils.mergeSets(previous.liveTypes, committedItems.getCommittedProgramTypes()),
previous.targetedMethods,
- previous.failedResolutionTargets,
+ previous.failedMethodResolutionTargets,
+ previous.failedFieldResolutionTargets,
previous.bootstrapMethods,
previous.methodsTargetedByInvokeDynamic,
previous.virtualMethodsTargetedByInvokeDirect,
@@ -328,7 +334,8 @@
? Sets.difference(previous.liveTypes, prunedItems.getRemovedClasses())
: previous.liveTypes,
previous.targetedMethods,
- previous.failedResolutionTargets,
+ previous.failedMethodResolutionTargets,
+ previous.failedFieldResolutionTargets,
previous.bootstrapMethods,
previous.methodsTargetedByInvokeDynamic,
previous.virtualMethodsTargetedByInvokeDirect,
@@ -366,10 +373,11 @@
previous.initClassReferences);
}
- private void verify() {
+ private boolean verify() {
assert keepInfo.verifyPinnedTypesAreLive(liveTypes);
assert objectAllocationInfoCollection.verifyAllocatedTypesAreLive(
liveTypes, getMissingClasses(), this);
+ return true;
}
private static KeepInfoCollection extendPinnedItems(
@@ -419,7 +427,8 @@
this.deadProtoTypes = previous.deadProtoTypes;
this.liveTypes = previous.liveTypes;
this.targetedMethods = previous.targetedMethods;
- this.failedResolutionTargets = previous.failedResolutionTargets;
+ this.failedMethodResolutionTargets = previous.failedMethodResolutionTargets;
+ this.failedFieldResolutionTargets = previous.failedFieldResolutionTargets;
this.bootstrapMethods = previous.bootstrapMethods;
this.methodsTargetedByInvokeDynamic = previous.methodsTargetedByInvokeDynamic;
this.virtualMethodsTargetedByInvokeDirect = previous.virtualMethodsTargetedByInvokeDirect;
@@ -454,7 +463,7 @@
this.lockCandidates = previous.lockCandidates;
this.initClassReferences = previous.initClassReferences;
previous.markObsolete();
- verify();
+ assert verify();
}
public static AppInfoWithLivenessModifier modifier() {
@@ -470,8 +479,7 @@
// TODO(b/150693139): Remove these exceptions once fixed.
|| InterfaceMethodRewriter.isCompanionClassType(type)
|| InterfaceMethodRewriter.isEmulatedLibraryClassType(type)
- || type.toDescriptorString().startsWith("Lj$/$r8$retargetLibraryMember$")
- || TwrCloseResourceRewriter.isUtilityClassDescriptor(type)
+ || DesugaredLibraryRetargeter.isRetargetType(type, options())
// TODO(b/150736225): Not sure how to remove these.
|| DesugaredLibraryAPIConverter.isVivifiedType(type)
: "Failed lookup of non-missing type: " + type;
@@ -533,11 +541,15 @@
}
public boolean isFailedResolutionTarget(DexMethod method) {
- return failedResolutionTargets.contains(method);
+ return failedMethodResolutionTargets.contains(method);
}
- public Set<DexMethod> getFailedResolutionTargets() {
- return failedResolutionTargets;
+ public Set<DexMethod> getFailedMethodResolutionTargets() {
+ return failedMethodResolutionTargets;
+ }
+
+ public Set<DexField> getFailedFieldResolutionTargets() {
+ return failedFieldResolutionTargets;
}
public boolean isBootstrapMethod(DexMethod method) {
@@ -604,8 +616,7 @@
return reprocess;
}
- public Collection<DexClass> computeReachableInterfaces() {
- Set<DexClass> interfaces = Sets.newIdentityHashSet();
+ public void forEachReachableInterface(Consumer<DexClass> consumer) {
WorkList<DexType> worklist = WorkList.newIdentityWorkList();
worklist.addIfNotSeen(objectAllocationInfoCollection.getInstantiatedLambdaInterfaces());
for (DexProgramClass clazz : classes()) {
@@ -618,14 +629,13 @@
continue;
}
if (definition.isInterface()) {
- interfaces.add(definition);
+ consumer.accept(definition);
}
if (definition.superType != null) {
worklist.addIfNotSeen(definition.superType);
}
worklist.addIfNotSeen(definition.interfaces.values);
}
- return interfaces;
}
/**
@@ -999,7 +1009,8 @@
getMissingClasses().commitSyntheticItems(committedItems),
lens.rewriteTypes(liveTypes),
lens.rewriteMethods(targetedMethods),
- lens.rewriteMethods(failedResolutionTargets),
+ lens.rewriteMethods(failedMethodResolutionTargets),
+ lens.rewriteFields(failedFieldResolutionTargets),
lens.rewriteMethods(bootstrapMethods),
lens.rewriteMethods(methodsTargetedByInvokeDynamic),
lens.rewriteMethods(virtualMethodsTargetedByInvokeDirect),
@@ -1351,12 +1362,7 @@
// The type java.lang.Object could be any instantiated type. Assume a finalizer exists.
return true;
}
- for (DexType iface : type.getInterfaces()) {
- if (mayHaveFinalizer(iface)) {
- return true;
- }
- }
- return false;
+ return type.getInterfaces().anyMatch((iface, isKnown) -> mayHaveFinalizer(iface));
}
return mayHaveFinalizer(type.getClassType());
}
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index c15fdb8..f7ac800 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -5,6 +5,8 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.graph.FieldAccessInfoImpl.MISSING_FIELD_ACCESS_INFO;
+import static com.android.tools.r8.ir.desugar.LambdaDescriptor.isLambdaMetafactoryMethod;
+import static com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX;
import static com.android.tools.r8.naming.IdentifierNameStringUtils.identifyIdentifier;
import static com.android.tools.r8.naming.IdentifierNameStringUtils.isReflectionMethod;
import static com.android.tools.r8.shaking.AnnotationRemover.shouldKeepAnnotation;
@@ -19,6 +21,7 @@
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.Code;
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexApplication;
@@ -55,6 +58,7 @@
import com.android.tools.r8.graph.LookupLambdaTarget;
import com.android.tools.r8.graph.LookupTarget;
import com.android.tools.r8.graph.MethodAccessInfoCollection;
+import com.android.tools.r8.graph.NestMemberClassAttribute;
import com.android.tools.r8.graph.ObjectAllocationInfoCollectionImpl;
import com.android.tools.r8.graph.ProgramDefinition;
import com.android.tools.r8.graph.ProgramField;
@@ -86,6 +90,8 @@
import com.android.tools.r8.ir.desugar.LambdaClass;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.ir.desugar.LambdaRewriter;
+import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
+import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.kotlin.KotlinMetadataEnqueuerExtension;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.naming.identifiernamestring.IdentifierNameStringLookupResult;
@@ -103,12 +109,15 @@
import com.android.tools.r8.utils.Action;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.DesugarState;
+import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
import com.android.tools.r8.utils.IteratorUtils;
+import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.StringDiagnostic;
+import com.android.tools.r8.utils.ThreadUtils;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.Visibility;
import com.android.tools.r8.utils.WorkList;
@@ -118,6 +127,7 @@
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
@@ -134,6 +144,7 @@
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
+import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
@@ -162,7 +173,8 @@
public enum Mode {
INITIAL_TREE_SHAKING,
FINAL_TREE_SHAKING,
- MAIN_DEX_TRACING,
+ INITIAL_MAIN_DEX_TRACING,
+ FINAL_MAIN_DEX_TRACING,
WHY_ARE_YOU_KEEPING;
public boolean isInitialTreeShaking() {
@@ -177,8 +189,16 @@
return isInitialTreeShaking() || isFinalTreeShaking();
}
- public boolean isTracingMainDex() {
- return this == MAIN_DEX_TRACING;
+ public boolean isInitialMainDexTracing() {
+ return this == INITIAL_MAIN_DEX_TRACING;
+ }
+
+ public boolean isFinalMainDexTracing() {
+ return this == FINAL_MAIN_DEX_TRACING;
+ }
+
+ public boolean isMainDexTracing() {
+ return isInitialMainDexTracing() || isFinalMainDexTracing();
}
public boolean isWhyAreYouKeeping() {
@@ -198,10 +218,10 @@
// Don't hold a direct pointer to app info (use appView).
private AppInfoWithClassHierarchy appInfo;
private final AppView<AppInfoWithClassHierarchy> appView;
+ private final ExecutorService executorService;
private SubtypingInfo subtypingInfo;
private final InternalOptions options;
private RootSet rootSet;
- private ProguardClassFilter dontWarnPatterns;
private final EnqueuerUseRegistryFactory useRegistryFactory;
private AnnotationRemover.Builder annotationRemoverBuilder;
private final EnqueuerDefinitionSupplier enqueuerDefinitionSupplier =
@@ -283,7 +303,10 @@
private final SetWithReason<DexEncodedMethod> targetedMethods;
/** Set of methods that have invalid resolutions or lookups. */
- private final Set<DexMethod> failedResolutionTargets;
+ private final Set<DexMethod> failedMethodResolutionTargets;
+
+ /** Set of methods that have invalid resolutions or lookups. */
+ private final Set<DexField> failedFieldResolutionTargets;
/**
* Set of program methods that are used as the bootstrap method for an invoke-dynamic instruction.
@@ -359,23 +382,32 @@
private final LambdaRewriter lambdaRewriter;
private final BackportedMethodRewriter backportRewriter;
+ private final NestBasedAccessDesugaring nestBasedAccessRewriter;
+ private final TwrCloseResourceRewriter twrCloseResourceRewriter;
+
private final DesugaredLibraryConversionWrapperAnalysis desugaredLibraryWrapperAnalysis;
private final Map<DexType, Pair<LambdaClass, ProgramMethod>> lambdaClasses =
new IdentityHashMap<>();
private final ProgramMethodMap<Map<DexCallSite, LambdaClass>> lambdaCallSites =
ProgramMethodMap.create();
private final Map<DexMethod, ProgramMethod> methodsWithBackports = new IdentityHashMap<>();
+ private final Map<DexMethod, ProgramMethod> methodsWithTwrCloseResource = new IdentityHashMap<>();
private final Set<DexProgramClass> classesWithSerializableLambdas = Sets.newIdentityHashSet();
+ private final ProgramMethodSet pendingDesugaring = ProgramMethodSet.create();
+ private final MainDexTracingResult previousMainDexTracingResult;
Enqueuer(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo,
GraphConsumer keptGraphConsumer,
- Mode mode) {
+ Mode mode,
+ MainDexTracingResult previousMainDexTracingResult) {
assert appView.appServices() != null;
InternalOptions options = appView.options();
this.appInfo = appView.appInfo();
this.appView = appView.withClassHierarchy();
+ this.executorService = executorService;
this.subtypingInfo = subtypingInfo;
this.forceProguardCompatibility = options.forceProguardCompatibility;
this.graphReporter = new GraphReporter(appView, keptGraphConsumer);
@@ -384,6 +416,7 @@
this.options = options;
this.useRegistryFactory = createUseRegistryFactory();
this.workList = EnqueuerWorklist.createWorklist();
+ this.previousMainDexTracingResult = previousMainDexTracingResult;
if (mode.isInitialOrFinalTreeShaking()) {
if (options.protoShrinking().enableGeneratedMessageLiteShrinking) {
@@ -397,12 +430,19 @@
// This set is only populated in edge cases due to multiple default interface methods.
// The set is generally expected to be empty and in the unlikely chance it is not, it will
// likely contain two methods. Thus the default capacity of 2.
- failedResolutionTargets = SetUtils.newIdentityHashSet(2);
+ failedMethodResolutionTargets = SetUtils.newIdentityHashSet(2);
+ failedFieldResolutionTargets = SetUtils.newIdentityHashSet(0);
liveMethods = new LiveMethodsSet(graphReporter::registerMethod);
liveFields = new LiveFieldsSet(graphReporter::registerField);
lambdaRewriter = options.desugarState == DesugarState.ON ? new LambdaRewriter(appView) : null;
+ nestBasedAccessRewriter =
+ options.shouldDesugarNests() ? new NestBasedAccessDesugaring(appView) : null;
backportRewriter =
options.desugarState == DesugarState.ON ? new BackportedMethodRewriter(appView) : null;
+ twrCloseResourceRewriter =
+ TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(options)
+ ? new TwrCloseResourceRewriter(appView)
+ : null;
objectAllocationInfoCollection =
ObjectAllocationInfoCollectionImpl.builder(mode.isInitialTreeShaking(), graphReporter);
@@ -517,10 +557,15 @@
}
private void recordMethodReference(DexMethod method, ProgramDefinition context) {
- recordTypeReference(method.holder, context);
- recordTypeReference(method.proto.returnType, context);
+ recordMethodReference(method, context, this::reportMissingClass);
+ }
+
+ private void recordMethodReference(
+ DexMethod method, ProgramDefinition context, Consumer<DexType> missingClassConsumer) {
+ recordTypeReference(method.holder, context, missingClassConsumer);
+ recordTypeReference(method.proto.returnType, context, missingClassConsumer);
for (DexType type : method.proto.parameters.values) {
- recordTypeReference(type, context);
+ recordTypeReference(type, context, missingClassConsumer);
}
}
@@ -905,13 +950,17 @@
}
void traceCallSite(DexCallSite callSite, ProgramMethod context) {
- DexProgramClass bootstrapClass =
- getProgramHolderOrNull(callSite.bootstrapMethod.asMethod(), context);
- if (bootstrapClass != null) {
- bootstrapMethods.add(callSite.bootstrapMethod.asMethod());
+ // Do not lookup java.lang.invoke.LambdaMetafactory when compiling for DEX to avoid reporting
+ // the class as missing.
+ if (options.isGeneratingClassFiles() || !isLambdaMetafactoryMethod(callSite, appInfo())) {
+ DexProgramClass bootstrapClass =
+ getProgramHolderOrNull(callSite.bootstrapMethod.asMethod(), context);
+ if (bootstrapClass != null) {
+ bootstrapMethods.add(callSite.bootstrapMethod.asMethod());
+ }
}
- LambdaDescriptor descriptor = LambdaDescriptor.tryInfer(callSite, appInfo, context);
+ LambdaDescriptor descriptor = LambdaDescriptor.tryInfer(callSite, appInfo(), context);
if (descriptor == null) {
return;
}
@@ -921,7 +970,7 @@
assert contextMethod.getCode().isCfCode() : "Unexpected input type with lambdas";
CfCode code = contextMethod.getCode().asCfCode();
if (code != null) {
- LambdaClass lambdaClass = lambdaRewriter.getOrCreateLambdaClass(descriptor, context);
+ LambdaClass lambdaClass = lambdaRewriter.createLambdaClass(descriptor, context);
lambdaClasses.put(lambdaClass.type, new Pair<>(lambdaClass, context));
lambdaCallSites
.computeIfAbsent(context, k -> new IdentityHashMap<>())
@@ -1234,12 +1283,24 @@
return false;
}
+ private boolean registerCloseResource(DexMethod invokedMethod, ProgramMethod context) {
+ if (twrCloseResourceRewriter != null
+ && TwrCloseResourceRewriter.isTwrCloseResourceMethod(
+ invokedMethod, appView.dexItemFactory())) {
+ methodsWithTwrCloseResource.putIfAbsent(context.getReference(), context);
+ return true;
+ }
+ return false;
+ }
+
private void traceInvokeStatic(
DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
if (registerBackportInvoke(invokedMethod, context)) {
return;
}
-
+ if (registerCloseResource(invokedMethod, context)) {
+ return;
+ }
DexItemFactory dexItemFactory = appView.dexItemFactory();
if (dexItemFactory.classMethods.isReflectiveClassLookup(invokedMethod)
|| dexItemFactory.atomicFieldUpdaterMethods.isFieldUpdater(invokedMethod)) {
@@ -1659,18 +1720,38 @@
return;
}
+ assert !mode.isFinalMainDexTracing()
+ || !options.testing.checkForNotExpandingMainDexTracingResult
+ || previousMainDexTracingResult.isRoot(clazz)
+ || clazz.toSourceString().contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)
+ // TODO(b/177847090): Consider not outlining anything in main dex.
+ || clazz.toSourceString().contains(OutlineOptions.CLASS_NAME)
+ : "Class " + clazz.toSourceString() + " was not a main dex root in the first round";
+
// Mark types in inner-class attributes referenced.
for (InnerClassAttribute innerClassAttribute : clazz.getInnerClasses()) {
recordTypeReference(innerClassAttribute.getInner(), clazz, this::ignoreMissingClass);
recordTypeReference(innerClassAttribute.getOuter(), clazz, this::ignoreMissingClass);
}
+
+ // Mark types in nest attributes referenced.
+ if (clazz.isNestHost()) {
+ for (NestMemberClassAttribute nestMemberClassAttribute :
+ clazz.getNestMembersClassAttributes()) {
+ recordTypeReference(nestMemberClassAttribute.getNestMember(), clazz);
+ }
+ } else {
+ recordTypeReference(clazz.getNestHost(), clazz);
+ }
+
EnclosingMethodAttribute enclosingMethodAttribute = clazz.getEnclosingMethodAttribute();
if (enclosingMethodAttribute != null) {
DexMethod enclosingMethod = enclosingMethodAttribute.getEnclosingMethod();
if (enclosingMethod != null) {
- recordMethodReference(enclosingMethod, clazz);
+ recordMethodReference(enclosingMethod, clazz, this::ignoreMissingClass);
} else {
- recordTypeReference(enclosingMethodAttribute.getEnclosingClass(), clazz);
+ recordTypeReference(
+ enclosingMethodAttribute.getEnclosingClass(), clazz, this::ignoreMissingClass);
}
}
@@ -1680,7 +1761,7 @@
KeepReason reason = KeepReason.reachableFromLiveType(clazz.type);
- for (DexType iface : clazz.interfaces.values) {
+ for (DexType iface : clazz.getInterfaces()) {
markInterfaceTypeAsLiveViaInheritanceClause(iface, clazz);
}
@@ -1766,33 +1847,40 @@
if (!appView.options().enableUnusedInterfaceRemoval
|| rootSet.noUnusedInterfaceRemoval.contains(type)
- || mode.isTracingMainDex()) {
+ || mode.isMainDexTracing()) {
markTypeAsLive(clazz, implementer);
- } else {
- if (liveTypes.contains(clazz)) {
- // The interface is already live, so make sure to report this implements-edge.
- graphReporter.reportClassReferencedFrom(clazz, implementer);
- } else {
- // No need to mark the type as live. If an interface type is only reachable via the
- // inheritance clause of another type it can simply be removed from the inheritance clause.
- // The interface is needed if it has a live default interface method or field, though.
- // Therefore, we record that this implemented-by edge has not been reported, such that we
- // can report it in the future if one its members becomes live.
- WorkList<DexProgramClass> worklist = WorkList.newIdentityWorkList();
- worklist.addIfNotSeen(clazz);
- while (worklist.hasNext()) {
- DexProgramClass current = worklist.next();
- if (liveTypes.contains(current)) {
- continue;
- }
- Set<DexProgramClass> implementors =
- unusedInterfaceTypes.computeIfAbsent(current, ignore -> Sets.newIdentityHashSet());
- if (implementors.add(implementer)) {
- for (DexType iface : current.interfaces.values) {
- DexProgramClass definition = getProgramClassOrNull(iface, current);
- if (definition != null) {
- worklist.addIfNotSeen(definition);
- }
+ return;
+ }
+
+ if (liveTypes.contains(clazz)) {
+ // The interface is already live, so make sure to report this implements-edge.
+ graphReporter.reportClassReferencedFrom(clazz, implementer);
+ return;
+ }
+
+ // No need to mark the type as live. If an interface type is only reachable via the
+ // inheritance clause of another type it can simply be removed from the inheritance clause.
+ // The interface is needed if it has a live default interface method or field, though.
+ // Therefore, we record that this implemented-by edge has not been reported, such that we
+ // can report it in the future if one its members becomes live.
+ WorkList<DexProgramClass> worklist = WorkList.newIdentityWorkList();
+ worklist.addIfNotSeen(clazz);
+ while (worklist.hasNext()) {
+ DexProgramClass current = worklist.next();
+ if (liveTypes.contains(current)) {
+ continue;
+ }
+ Set<DexProgramClass> implementors =
+ unusedInterfaceTypes.computeIfAbsent(current, ignore -> Sets.newIdentityHashSet());
+ if (implementors.add(implementer)) {
+ for (DexType iface : current.getInterfaces()) {
+ DexProgramClass definition = getProgramClassOrNull(iface, current);
+ if (definition != null) {
+ if (definition.isPublic()
+ || implementer.getType().isSamePackage(definition.getType())) {
+ worklist.addIfNotSeen(definition);
+ } else {
+ markTypeAsLive(current, implementer);
}
}
}
@@ -1859,6 +1947,7 @@
FieldResolutionResult resolutionResult = appInfo.resolveField(field);
if (resolutionResult.isFailedOrUnknownResolution()) {
reportMissingField(field);
+ failedFieldResolutionTargets.add(field);
}
return resolutionResult;
}
@@ -1870,7 +1959,8 @@
ResolutionResult resolutionResult = appInfo.unsafeResolveMethodDueToDexFormat(method);
if (resolutionResult.isFailedResolution()) {
reportMissingMethod(method);
- markFailedResolutionTargets(method, resolutionResult.asFailedResolution(), context, reason);
+ markFailedMethodResolutionTargets(
+ method, resolutionResult.asFailedResolution(), context, reason);
}
return resolutionResult.asSingleResolution();
}
@@ -1882,7 +1972,8 @@
ResolutionResult resolutionResult = appInfo.resolveMethod(method, interfaceInvoke);
if (resolutionResult.isFailedResolution()) {
reportMissingMethod(method);
- markFailedResolutionTargets(method, resolutionResult.asFailedResolution(), context, reason);
+ markFailedMethodResolutionTargets(
+ method, resolutionResult.asFailedResolution(), context, reason);
}
return resolutionResult.asSingleResolution();
}
@@ -2020,6 +2111,7 @@
// TODO(zerny): Is it ok that we lookup in both the direct and virtual pool here?
DexEncodedMethod encodedMethod = clazz.lookupMethod(reference);
if (encodedMethod == null) {
+ failedMethodResolutionTargets.add(reference);
reportMissingMethod(reference);
return;
}
@@ -2047,7 +2139,7 @@
}
private void ensureFromLibraryOrThrow(DexType type, DexLibraryClass context) {
- if (mode.isTracingMainDex()) {
+ if (mode.isMainDexTracing()) {
// b/72312389: android.jar contains parts of JUnit and most developers include JUnit in
// their programs. This leads to library classes extending program classes. When tracing
// main dex lists we allow this.
@@ -2071,7 +2163,7 @@
}
});
}
- if (dontWarnPatterns.matches(context.type)) {
+ if (appView.getDontWarnConfiguration().matches(context)) {
// Ignore.
return;
}
@@ -2245,20 +2337,24 @@
private void checkLambdaInterface(DexType itf, ProgramMethod context) {
DexClass clazz = definitionFor(itf, context);
if (clazz == null) {
- StringDiagnostic message =
- new StringDiagnostic(
- "Lambda expression implements missing interface `" + itf.toSourceString() + "`",
- context.getOrigin());
- options.reporter.warning(message);
+ if (!appView.getDontWarnConfiguration().matches(itf)) {
+ StringDiagnostic message =
+ new StringDiagnostic(
+ "Lambda expression implements missing interface `" + itf.toSourceString() + "`",
+ context.getOrigin());
+ options.reporter.warning(message);
+ }
} else if (!clazz.isInterface()) {
- StringDiagnostic message =
- new StringDiagnostic(
- "Lambda expression expected to implement an interface, but found "
- + "`"
- + itf.toSourceString()
- + "`",
- context.getOrigin());
- options.reporter.warning(message);
+ if (!appView.getDontWarnConfiguration().matches(itf)) {
+ StringDiagnostic message =
+ new StringDiagnostic(
+ "Lambda expression expected to implement an interface, but found "
+ + "`"
+ + itf.toSourceString()
+ + "`",
+ context.getOrigin());
+ options.reporter.warning(message);
+ }
}
}
@@ -2385,7 +2481,7 @@
private void markLibraryAndClasspathMethodOverridesAsLive(
InstantiatedObject instantiation, DexClass libraryClass) {
assert libraryClass.isNotProgramClass();
- if (mode.isTracingMainDex()) {
+ if (mode.isMainDexTracing()) {
// Library roots must be specified for tracing of library methods. For classpath the expected
// use case is that the classes will be classloaded, thus they should have no bearing on the
// content of the main dex file.
@@ -2804,17 +2900,17 @@
}
}
- private void markFailedResolutionTargets(
+ private void markFailedMethodResolutionTargets(
DexMethod symbolicMethod,
FailedResolutionResult failedResolution,
ProgramDefinition context,
KeepReason reason) {
- failedResolutionTargets.add(symbolicMethod);
+ failedMethodResolutionTargets.add(symbolicMethod);
failedResolution.forEachFailureDependency(
method -> {
DexProgramClass clazz = getProgramClassOrNull(method.getHolderType(), context);
if (clazz != null) {
- failedResolutionTargets.add(method.method);
+ failedMethodResolutionTargets.add(method.method);
markMethodAsTargeted(new ProgramMethod(clazz, method), reason);
}
});
@@ -2860,7 +2956,7 @@
// If invoke target is invalid (inaccessible or not an instance-method) record it and stop.
DexClassAndMethod target = resolution.lookupInvokeSuperTarget(from.getHolder(), appInfo);
if (target == null) {
- failedResolutionTargets.add(resolution.getResolvedMethod().method);
+ failedMethodResolutionTargets.add(resolution.getResolvedMethod().method);
return;
}
@@ -2891,7 +2987,7 @@
public Set<DexProgramClass> traceMainDex(
RootSet rootSet, ExecutorService executorService, Timing timing) throws ExecutionException {
assert analyses.isEmpty();
- assert mode.isTracingMainDex();
+ assert mode.isMainDexTracing();
this.rootSet = rootSet;
// Translate the result of root-set computation into enqueuer actions.
enqueueRootItems(rootSet.noShrinking);
@@ -2902,12 +2998,10 @@
public AppInfoWithLiveness traceApplication(
RootSet rootSet,
- ProguardClassFilter dontWarnPatterns,
ExecutorService executorService,
Timing timing)
throws ExecutionException {
this.rootSet = rootSet;
- this.dontWarnPatterns = dontWarnPatterns;
// Translate the result of root-set computation into enqueuer actions.
if (appView.options().getProguardConfiguration() != null
&& !options.kotlinOptimizationOptions().disableKotlinSpecificOptimizations) {
@@ -3012,6 +3106,8 @@
private static class SyntheticAdditions {
+ List<ProgramMethod> desugaredMethods = new LinkedList<>();
+
Map<DexType, Pair<DexProgramClass, ProgramMethod>> syntheticInstantiations =
new IdentityHashMap<>();
@@ -3020,6 +3116,8 @@
Map<DexMethod, ProgramMethod> liveMethods = new IdentityHashMap<>();
+ Map<DexType, DexProgramClass> syntheticProgramClasses = new IdentityHashMap<>();
+
Map<DexType, DexClasspathClass> syntheticClasspathClasses = new IdentityHashMap<>();
// Subset of live methods that need have keep requirements.
@@ -3031,20 +3129,18 @@
boolean isEmpty() {
boolean empty =
- syntheticInstantiations.isEmpty()
+ desugaredMethods.isEmpty()
+ && syntheticInstantiations.isEmpty()
&& liveMethods.isEmpty()
+ && syntheticProgramClasses.isEmpty()
&& syntheticClasspathClasses.isEmpty();
assert !empty || (liveMethodsWithKeepActions.isEmpty() && mainDexTypes.isEmpty());
return empty;
}
- void addInstantiatedClass(
- DexProgramClass clazz, ProgramMethod context, boolean isMainDexClass) {
+ void addInstantiatedClass(DexProgramClass clazz, ProgramMethod context) {
assert !syntheticInstantiations.containsKey(clazz.type);
syntheticInstantiations.put(clazz.type, new Pair<>(clazz, context));
- if (isMainDexClass) {
- mainDexTypes.add(clazz);
- }
}
void addClasspathClass(DexClasspathClass clazz) {
@@ -3052,6 +3148,11 @@
assert old == null;
}
+ void addProgramClass(DexProgramClass clazz) {
+ DexProgramClass old = syntheticProgramClasses.put(clazz.type, clazz);
+ assert old == null;
+ }
+
void addLiveMethod(ProgramMethod method) {
DexMethod signature = method.getDefinition().method;
assert !liveMethods.containsKey(signature);
@@ -3066,10 +3167,7 @@
void amendApplication(Builder appBuilder) {
assert !isEmpty();
- for (Pair<DexProgramClass, ProgramMethod> clazzAndContext :
- syntheticInstantiations.values()) {
- appBuilder.addProgramClass(clazzAndContext.getFirst());
- }
+ appBuilder.addProgramClasses(syntheticProgramClasses.values());
appBuilder.addClasspathClasses(syntheticClasspathClasses.values());
}
@@ -3081,9 +3179,14 @@
void enqueueWorkItems(Enqueuer enqueuer) {
assert !isEmpty();
assert enqueuer.mode.isInitialTreeShaking();
+
// All synthetic additions are initial tree shaking only. No need to track keep reasons.
KeepReasonWitness fakeReason = enqueuer.graphReporter.fakeReportShouldNotBeUsed();
+ for (ProgramMethod desugaredMethod : desugaredMethods) {
+ enqueuer.workList.enqueueTraceCodeAction(desugaredMethod);
+ }
+
liveMethodsWithKeepActions.forEach(
item -> enqueuer.keepInfo.joinMethod(item.getFirst(), item.getSecond()));
for (Pair<DexProgramClass, ProgramMethod> clazzAndContext :
@@ -3127,7 +3230,7 @@
}
}
- private void synthesize() {
+ private void synthesize() throws ExecutionException {
if (!mode.isInitialTreeShaking()) {
return;
}
@@ -3135,11 +3238,14 @@
// In particular these additions are order independent, i.e., it does not matter which are
// registered first and no dependencies may exist among them.
SyntheticAdditions additions = new SyntheticAdditions();
+ desugar(additions);
synthesizeInvokeSpecialBridges(additions);
synthesizeInterfaceMethodBridges(additions);
synthesizeLambdas(additions);
synthesizeLibraryConversionWrappers(additions);
synthesizeBackports(additions);
+ synthesizeNestConstructor(additions);
+ synthesizeTwrCloseResource(additions);
if (additions.isEmpty()) {
return;
}
@@ -3161,6 +3267,50 @@
additions.enqueueWorkItems(this);
}
+ private void desugar(SyntheticAdditions additions) throws ExecutionException {
+ ThreadUtils.processItems(pendingDesugaring, this::desugar, executorService);
+ Iterables.addAll(additions.desugaredMethods, pendingDesugaring);
+ pendingDesugaring.clear();
+ }
+
+ private void desugar(ProgramMethod method) {
+ Code code = method.getDefinition().getCode();
+ if (!code.isCfCode()) {
+ appView
+ .options()
+ .reporter
+ .error(
+ new StringDiagnostic(
+ "Unsupported attempt to desugar non-CF code",
+ method.getOrigin(),
+ method.getPosition()));
+ return;
+ }
+
+ CfCode cfCode = code.asCfCode();
+ List<CfInstruction> desugaredInstructions =
+ ListUtils.flatMap(
+ cfCode.getInstructions(),
+ instruction -> {
+ // TODO(b/177810578): Migrate other cf-to-cf based desugaring here, and assert that
+ // that at most one instruction desugarer applies to each instruction.
+ if (nestBasedAccessRewriter != null) {
+ List<CfInstruction> replacement =
+ nestBasedAccessRewriter.desugarInstruction(instruction, method, null);
+ if (replacement != null) {
+ return replacement;
+ }
+ }
+ return null;
+ },
+ null);
+ if (desugaredInstructions != null) {
+ cfCode.setInstructions(desugaredInstructions);
+ } else {
+ assert false : "Expected code to be desugared";
+ }
+ }
+
private void synthesizeInvokeSpecialBridges(SyntheticAdditions additions) {
SortedProgramMethodSet bridges =
appView.getInvokeSpecialBridgeSynthesizer().insertBridgesForR8();
@@ -3183,6 +3333,22 @@
}
}
+ private void synthesizeNestConstructor(SyntheticAdditions additions) {
+ if (nestBasedAccessRewriter != null) {
+ DexProgramClass nestConstructor = nestBasedAccessRewriter.synthesizeNestConstructor();
+ if (nestConstructor != null) {
+ // TODO(b/177638147): use getSyntheticItems().createClass().
+ additions.addProgramClass(nestConstructor);
+ }
+ }
+ }
+
+ private void synthesizeTwrCloseResource(SyntheticAdditions additions) {
+ for (ProgramMethod method : methodsWithTwrCloseResource.values()) {
+ twrCloseResourceRewriter.rewriteCf(method, additions::addLiveMethod);
+ }
+ }
+
private void synthesizeLambdas(SyntheticAdditions additions) {
if (lambdaRewriter == null || lambdaClasses.isEmpty()) {
assert lambdaCallSites.isEmpty();
@@ -3193,8 +3359,8 @@
// Add all desugared classes to the application, main-dex list, and mark them instantiated.
LambdaClass lambdaClass = lambdaClassAndContext.getFirst();
ProgramMethod context = lambdaClassAndContext.getSecond();
- DexProgramClass programClass = lambdaClass.getOrCreateLambdaClass();
- additions.addInstantiatedClass(programClass, context, lambdaClass.addToMainDexList.get());
+ DexProgramClass programClass = lambdaClass.getLambdaProgramClass();
+ additions.addInstantiatedClass(programClass, context);
// Mark the instance constructor targeted and live.
DexEncodedMethod constructor = programClass.lookupDirectMethod(lambdaClass.constructor);
KeepReason reason = KeepReason.instantiatedIn(context);
@@ -3299,11 +3465,12 @@
appInfo.getMainDexClasses(),
deadProtoTypes,
appView.testing().enableExperimentalMissingClassesReporting
- ? missingClassesBuilder.reportMissingClasses(options)
+ ? missingClassesBuilder.reportMissingClasses(appView)
: missingClassesBuilder.ignoreMissingClasses(),
SetUtils.mapIdentityHashSet(liveTypes.getItems(), DexProgramClass::getType),
Enqueuer.toDescriptorSet(targetedMethods.getItems()),
- Collections.unmodifiableSet(failedResolutionTargets),
+ Collections.unmodifiableSet(failedMethodResolutionTargets),
+ Collections.unmodifiableSet(failedFieldResolutionTargets),
Collections.unmodifiableSet(bootstrapMethods),
Collections.unmodifiableSet(methodsTargetedByInvokeDynamic),
Collections.unmodifiableSet(virtualMethodsTargetedByInvokeDirect),
@@ -3349,10 +3516,9 @@
lambdaRewriter
.getKnownLambdaClasses()
.forEach(
- (type, lambda) -> {
- DexProgramClass synthesizedClass = lambda.getOrCreateLambdaClass();
+ lambda -> {
+ DexProgramClass synthesizedClass = lambda.getLambdaProgramClass();
assert synthesizedClass != null;
- assert synthesizedClass == appInfo().definitionForWithoutExistenceAssert(type);
assert liveTypes.contains(synthesizedClass);
if (synthesizedClass == null) {
return;
@@ -3835,7 +4001,8 @@
processAnnotations(holder, method);
definition.parameterAnnotationsList.forEachAnnotation(
annotation -> processAnnotation(holder, method, annotation));
- method.registerCodeReferences(useRegistryFactory.create(appView, method, this));
+
+ traceNonDesugaredCode(method);
// Add all dependent members to the workqueue.
enqueueRootItems(rootSet.getDependentItems(definition));
@@ -3846,6 +4013,21 @@
analyses.forEach(analysis -> analysis.processNewlyLiveMethod(method, context));
}
+ private void traceNonDesugaredCode(ProgramMethod method) {
+ if (getMode().isInitialTreeShaking()) {
+ if (nestBasedAccessRewriter != null && nestBasedAccessRewriter.needsDesugaring(method)) {
+ pendingDesugaring.add(method);
+ return;
+ }
+ }
+
+ traceCode(method);
+ }
+
+ void traceCode(ProgramMethod method) {
+ method.registerCodeReferences(useRegistryFactory.create(appView, method, this));
+ }
+
private void checkMemberForSoftPinning(ProgramMember<?, ?> member) {
DexMember<?, ?> reference = member.getDefinition().getReference();
Set<ProguardKeepRuleBase> softPinRules = rootSet.softPinned.getRulesForReference(reference);
@@ -4510,7 +4692,7 @@
}
public DexClass definitionFor(DexType type, ProgramDefinition context) {
- return enqueuer.definitionFor(type, context);
+ return enqueuer.definitionFor(type, context, enqueuer::ignoreMissingClass);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
index 34a8750..04fb840 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
@@ -11,45 +11,82 @@
import com.android.tools.r8.graph.SubtypingInfo;
import com.android.tools.r8.shaking.Enqueuer.Mode;
import java.util.Set;
+import java.util.concurrent.ExecutorService;
public class EnqueuerFactory {
public static Enqueuer createForInitialTreeShaking(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo) {
- return new Enqueuer(appView, subtypingInfo, null, Mode.INITIAL_TREE_SHAKING);
+ return new Enqueuer(
+ appView,
+ executorService,
+ subtypingInfo,
+ null,
+ Mode.INITIAL_TREE_SHAKING,
+ MainDexTracingResult.NONE);
}
public static Enqueuer createForFinalTreeShaking(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo,
GraphConsumer keptGraphConsumer,
Set<DexType> initialPrunedTypes) {
Enqueuer enqueuer =
- new Enqueuer(appView, subtypingInfo, keptGraphConsumer, Mode.FINAL_TREE_SHAKING);
+ new Enqueuer(
+ appView,
+ executorService,
+ subtypingInfo,
+ keptGraphConsumer,
+ Mode.FINAL_TREE_SHAKING,
+ MainDexTracingResult.NONE);
appView.withProtoShrinker(
shrinker -> enqueuer.setInitialDeadProtoTypes(shrinker.getDeadProtoTypes()));
enqueuer.setInitialPrunedTypes(initialPrunedTypes);
return enqueuer;
}
- public static Enqueuer createForMainDexTracing(
+ public static Enqueuer createForInitialMainDexTracing(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo) {
- return createForMainDexTracing(appView, subtypingInfo, null);
+ return new Enqueuer(
+ appView,
+ executorService,
+ subtypingInfo,
+ null,
+ Mode.INITIAL_MAIN_DEX_TRACING,
+ MainDexTracingResult.NONE);
}
- public static Enqueuer createForMainDexTracing(
+ public static Enqueuer createForFinalMainDexTracing(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo,
- GraphConsumer keptGraphConsumer) {
- return new Enqueuer(appView, subtypingInfo, keptGraphConsumer, Mode.MAIN_DEX_TRACING);
+ GraphConsumer keptGraphConsumer,
+ MainDexTracingResult previousMainDexTracingResult) {
+ return new Enqueuer(
+ appView,
+ executorService,
+ subtypingInfo,
+ keptGraphConsumer,
+ Mode.FINAL_MAIN_DEX_TRACING,
+ previousMainDexTracingResult);
}
public static Enqueuer createForWhyAreYouKeeping(
AppView<? extends AppInfoWithClassHierarchy> appView,
+ ExecutorService executorService,
SubtypingInfo subtypingInfo,
GraphConsumer keptGraphConsumer) {
- return new Enqueuer(appView, subtypingInfo, keptGraphConsumer, Mode.WHY_ARE_YOU_KEEPING);
+ return new Enqueuer(
+ appView,
+ executorService,
+ subtypingInfo,
+ keptGraphConsumer,
+ Mode.WHY_ARE_YOU_KEEPING,
+ MainDexTracingResult.NONE);
}
}
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
index 0be900c..b403b54 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
@@ -174,6 +174,19 @@
}
}
+ static class TraceCodeAction extends EnqueuerAction {
+ private final ProgramMethod method;
+
+ TraceCodeAction(ProgramMethod method) {
+ this.method = method;
+ }
+
+ @Override
+ public void run(Enqueuer enqueuer) {
+ enqueuer.traceCode(method);
+ }
+ }
+
static class TraceConstClassAction extends EnqueuerAction {
private final DexType type;
// TODO(b/175854431): Avoid pushing context on worklist.
@@ -304,6 +317,10 @@
queue.add(new MarkFieldKeptAction(field, witness));
}
+ public void enqueueTraceCodeAction(ProgramMethod method) {
+ queue.add(new TraceCodeAction(method));
+ }
+
public void enqueueTraceConstClassAction(DexType type, ProgramMethod context) {
queue.add(new TraceConstClassAction(type, context));
}
diff --git a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
index 86b0d08..6459b7f 100644
--- a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
+++ b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
@@ -423,7 +423,7 @@
}
GraphEdgeInfo getEdgeInfo(EdgeKind kind) {
- return reasonInfo.computeIfAbsent(kind, k -> new GraphEdgeInfo(k));
+ return reasonInfo.computeIfAbsent(kind, GraphEdgeInfo::new);
}
private DexClass definitionFor(DexType type) {
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java b/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java
index 3af323c..5bf287f 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java
@@ -146,6 +146,10 @@
return getRoots().contains(definition.getContextType());
}
+ public boolean isRoot(DexType type) {
+ return getRoots().contains(type);
+ }
+
public boolean isDependency(ProgramDefinition definition) {
return getDependencies().contains(definition.getContextType());
}
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 d3cd164..e296cd7 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.shaking;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.synthesis.CommittedItems;
@@ -90,11 +91,13 @@
return build();
}
- public MissingClasses reportMissingClasses(InternalOptions options) {
+ public MissingClasses reportMissingClasses(AppView<?> appView) {
+ InternalOptions options = appView.options();
Set<DexType> newMissingClassesWithoutDontWarn =
- options.getProguardConfiguration().getDontWarnPatterns().getNonMatches(newMissingClasses);
+ appView.getDontWarnConfiguration().getNonMatches(newMissingClasses);
+ newMissingClassesWithoutDontWarn.removeAll(alreadyMissingClasses);
newMissingClassesWithoutDontWarn.removeAll(
- getAllowedMissingClasses(options.dexItemFactory()));
+ getAllowedMissingClasses(appView.dexItemFactory()));
if (!newMissingClassesWithoutDontWarn.isEmpty()) {
MissingClassesDiagnostic diagnostic =
new MissingClassesDiagnostic.Builder()
@@ -111,10 +114,18 @@
}
private static Collection<DexType> getAllowedMissingClasses(DexItemFactory dexItemFactory) {
- return ImmutableList.of(dexItemFactory.annotationThrows);
+ return ImmutableList.of(
+ dexItemFactory.annotationDefault,
+ dexItemFactory.annotationMethodParameters,
+ dexItemFactory.annotationSourceDebugExtension,
+ dexItemFactory.annotationThrows,
+ // TODO(b/176133674) StringConcatFactory is backported, but the class is reported as
+ // missing because the enqueuer runs prior to backporting and thus sees the non-desugared
+ // code.
+ dexItemFactory.stringConcatFactoryType);
}
- /** Intentionally private, use {@link Builder#reportMissingClasses(InternalOptions)}. */
+ /** Intentionally private, use {@link Builder#reportMissingClasses(AppView)}. */
private MissingClasses build() {
// Extend the newMissingClasses set with all other missing classes.
//
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardClassFilter.java b/src/main/java/com/android/tools/r8/shaking/ProguardClassFilter.java
index 88c13ec..2580817 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardClassFilter.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardClassFilter.java
@@ -4,14 +4,9 @@
package com.android.tools.r8.shaking;
-import static com.android.tools.r8.utils.PredicateUtils.not;
-
import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.shaking.ProguardTypeMatcher.MatchSpecificType;
-import com.android.tools.r8.utils.TraversalContinuation;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
-import java.util.Set;
+import java.util.List;
public class ProguardClassFilter {
private static ProguardClassFilter EMPTY = new ProguardClassFilter(ImmutableList.of());
@@ -46,6 +41,10 @@
return EMPTY;
}
+ public List<ProguardClassNameList> getPatterns() {
+ return patterns;
+ }
+
public boolean isEmpty() {
return patterns.size() == 0;
}
@@ -58,47 +57,4 @@
}
return false;
}
-
- public Set<DexType> getNonMatches(Set<DexType> types) {
- Set<DexType> nonMatches = Sets.newIdentityHashSet();
- for (DexType type : types) {
- TraversalContinuation traversalContinuation = TraversalContinuation.CONTINUE;
- for (ProguardClassNameList pattern : patterns) {
- traversalContinuation =
- pattern.traverseTypeMatchers(
- matcher -> {
- if (matcher.matches(type)) {
- return TraversalContinuation.BREAK;
- }
- return TraversalContinuation.CONTINUE;
- },
- not(ProguardTypeMatcher::hasSpecificType));
- if (traversalContinuation.shouldBreak()) {
- break;
- }
- }
- if (traversalContinuation.shouldContinue()) {
- nonMatches.add(type);
- }
- }
- for (ProguardClassNameList pattern : patterns) {
- pattern.forEachTypeMatcher(
- matcher -> nonMatches.remove(matcher.getSpecificType()),
- ProguardTypeMatcher::hasSpecificType);
- }
- return nonMatches;
- }
-
- public void filterOutMatches(Set<DexType> types) {
- for (ProguardClassNameList pattern : patterns) {
- pattern.forEachTypeMatcher(matcher -> {
- if (matcher instanceof MatchSpecificType) {
- assert matcher.getSpecificType() != null;
- types.remove(matcher.getSpecificType());
- } else {
- types.removeIf(matcher::matches);
- }
- });
- }
- }
}
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
index 7d8d88a..8fdd330 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking;
+import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.naming.DictionaryReader;
import com.android.tools.r8.origin.Origin;
@@ -627,7 +628,12 @@
return keepPackageNamesPatterns;
}
- public ProguardClassFilter getDontWarnPatterns() {
+ public boolean hasDontWarnPatterns() {
+ return !dontWarnPatterns.isEmpty();
+ }
+
+ public ProguardClassFilter getDontWarnPatterns(DontWarnConfiguration.Witness witness) {
+ assert witness != null;
return dontWarnPatterns;
}
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 47ac1e3..49e9f1e 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -40,6 +40,7 @@
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
+import java.util.function.IntPredicate;
import java.util.function.Predicate;
public class ProguardConfigurationParser {
@@ -1726,25 +1727,25 @@
return Integer.parseInt(s);
}
- private final Predicate<Integer> CLASS_NAME_PREDICATE =
- codePoint ->
- IdentifierUtils.isDexIdentifierPart(codePoint)
- || codePoint == '.'
- || codePoint == '*'
- || codePoint == '?'
- || codePoint == '%'
- || codePoint == '['
- || codePoint == ']';
+ private boolean isClassName(int codePoint) {
+ return IdentifierUtils.isDexIdentifierPart(codePoint)
+ || codePoint == '.'
+ || codePoint == '*'
+ || codePoint == '?'
+ || codePoint == '%'
+ || codePoint == '['
+ || codePoint == ']';
+ }
- private final Predicate<Integer> PACKAGE_NAME_PREDICATE =
- codePoint ->
- IdentifierUtils.isDexIdentifierPart(codePoint)
- || codePoint == '.'
- || codePoint == '*'
- || codePoint == '?';
+ private boolean isPackageName(int codePoint) {
+ return IdentifierUtils.isDexIdentifierPart(codePoint)
+ || codePoint == '.'
+ || codePoint == '*'
+ || codePoint == '?';
+ }
private String acceptClassName() {
- return acceptString(CLASS_NAME_PREDICATE);
+ return acceptString(this::isClassName);
}
private IdentifierPatternWithWildcards acceptIdentifierWithBackreference(IdentifierType kind) {
@@ -1842,8 +1843,8 @@
wildcardsCollector.add(new ProguardWildcard.Pattern(String.valueOf((char) current)));
end += Character.charCount(current);
} else if (kind == IdentifierType.PACKAGE_NAME
- ? PACKAGE_NAME_PREDICATE.test(current)
- : (CLASS_NAME_PREDICATE.test(current) || current == '>')) {
+ ? isPackageName(current)
+ : (isClassName(current) || current == '>')) {
end += Character.charCount(current);
} else if (kind != IdentifierType.PACKAGE_NAME && current == '<') {
currentBackreference = new StringBuilder();
@@ -1942,7 +1943,7 @@
|| codePoint == '.');
}
- private String acceptString(Predicate<Integer> codepointAcceptor) {
+ private String acceptString(IntPredicate codepointAcceptor) {
int start = position;
int end = position;
while (!eof(end)) {
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
index 42b56bd..c6afc11 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
@@ -134,11 +134,15 @@
if (rule.getClassType() != ProguardClassType.CLASS) {
continue;
}
+ if (!rule.getClassAnnotations().isEmpty() || !rule.getInheritanceAnnotations().isEmpty()) {
+ continue;
+ }
if (rule.hasInheritanceClassName()
&& !rule.getInheritanceClassName().matches(factory.objectType)) {
continue;
}
- if (!rule.getClassNames().matches(factory.androidOsBuildVersionType)) {
+ if (rule.getClassNames().hasWildcards()
+ || !rule.getClassNames().matches(factory.androidOsBuildVersionType)) {
continue;
}
for (ProguardMemberRule memberRule : rule.getMemberRules()) {
@@ -149,6 +153,9 @@
if (memberRule.getRuleType() != ProguardMemberType.FIELD) {
continue;
}
+ if (!memberRule.getAnnotations().isEmpty()) {
+ continue;
+ }
if (memberRule.getAccessFlags().isProtected()
|| memberRule.getAccessFlags().isPrivate()
|| memberRule.getAccessFlags().isAbstract()
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardMemberRuleReturnValue.java b/src/main/java/com/android/tools/r8/shaking/ProguardMemberRuleReturnValue.java
index c8545c7..11b8868 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardMemberRuleReturnValue.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardMemberRuleReturnValue.java
@@ -60,6 +60,10 @@
return type == Type.FIELD;
}
+ public boolean isNonNull() {
+ return isValueRange() && getValueRange().getMin() > 0;
+ }
+
public boolean isNull() {
return type == Type.NULL;
}
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
index 7f18fff..33bfc85 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -1727,11 +1727,7 @@
}
private void generateAssumeNoSideEffectsWarnings() {
- ProguardClassFilter dontWarnPatterns =
- options.getProguardConfiguration() != null
- ? options.getProguardConfiguration().getDontWarnPatterns()
- : ProguardClassFilter.empty();
- if (dontWarnPatterns.matches(options.itemFactory.objectType)) {
+ if (appView.getDontWarnConfiguration().matches(options.itemFactory.objectType)) {
// Don't report any warnings since we don't apply -assumenosideeffects rules to notify() or
// wait() anyway.
return;
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index e049766..c52fd0f 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -294,7 +294,7 @@
}
// The set of targets that must remain for proper resolution error cases should not be merged.
- for (DexMethod method : appInfo.getFailedResolutionTargets()) {
+ for (DexMethod method : appInfo.getFailedMethodResolutionTargets()) {
markTypeAsPinned(method.holder, AbortReason.RESOLUTION_FOR_METHODS_MAY_CHANGE);
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
index 424fd8d..2681a90 100644
--- a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
@@ -7,8 +7,6 @@
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexType;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.function.Function;
@@ -28,23 +26,19 @@
// Immutable package accessible fields to allow SyntheticItems creation.
final DexApplication application;
final int nextSyntheticId;
- final ImmutableSet<DexType> legacySyntheticTypes;
- final ImmutableMap<DexType, SyntheticReference> syntheticItems;
- final ImmutableList<DexType> committedTypes;
+ final CommittedSyntheticsCollection committed;
+ final ImmutableList<DexType> committedProgramTypes;
CommittedItems(
int nextSyntheticId,
DexApplication application,
- ImmutableSet<DexType> legacySyntheticTypes,
- ImmutableMap<DexType, SyntheticReference> syntheticItems,
- ImmutableList<DexType> committedTypes) {
- assert verifyTypesAreInApp(application, legacySyntheticTypes);
- assert verifyTypesAreInApp(application, syntheticItems.keySet());
+ CommittedSyntheticsCollection committed,
+ ImmutableList<DexType> committedProgramTypes) {
this.nextSyntheticId = nextSyntheticId;
this.application = application;
- this.legacySyntheticTypes = legacySyntheticTypes;
- this.syntheticItems = syntheticItems;
- this.committedTypes = committedTypes;
+ this.committed = committed;
+ this.committedProgramTypes = committedProgramTypes;
+ committed.verifyTypesAreInApp(application);
}
// Conversion to a mutable synthetic items collection. Should only be used in AppInfo creation.
@@ -56,13 +50,13 @@
return application;
}
- public Collection<DexType> getCommittedTypes() {
- return committedTypes;
+ public Collection<DexType> getCommittedProgramTypes() {
+ return committedProgramTypes;
}
@Deprecated
public Collection<DexType> getLegacySyntheticTypes() {
- return legacySyntheticTypes;
+ return committed.getLegacyTypes();
}
@Override
@@ -70,11 +64,4 @@
// All synthetic types are committed to the application so lookup is just the base lookup.
return baseDefinitionFor.apply(type);
}
-
- private static boolean verifyTypesAreInApp(DexApplication app, Collection<DexType> types) {
- for (DexType type : types) {
- assert app.programDefinitionFor(type) != null : "Missing synthetic: " + type;
- }
- return true;
- }
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java b/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
new file mode 100644
index 0000000..053b20b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedSyntheticsCollection.java
@@ -0,0 +1,246 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
+import com.android.tools.r8.graph.PrunedItems;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+/**
+ * Immutable collection of committed items.
+ *
+ * <p>This structure is to make it easier to pass the items from SyntheticItems to CommittedItems
+ * and back while also providing a builder for updating the committed synthetics.
+ */
+class CommittedSyntheticsCollection {
+
+ static class Builder {
+ private final CommittedSyntheticsCollection parent;
+ private ImmutableMap.Builder<DexType, SyntheticProgramClassReference> newNonLegacyClasses =
+ null;
+ private ImmutableMap.Builder<DexType, SyntheticMethodReference> newNonLegacyMethods = null;
+ private ImmutableSet.Builder<DexType> newLegacyClasses = null;
+
+ public Builder(CommittedSyntheticsCollection parent) {
+ this.parent = parent;
+ }
+
+ public Builder addItem(SyntheticDefinition<?, ?, ?> definition) {
+ if (definition.isProgramDefinition()) {
+ definition.asProgramDefinition().apply(this::addNonLegacyMethod, this::addNonLegacyClass);
+ }
+ return this;
+ }
+
+ public Builder addNonLegacyClass(SyntheticProgramClassDefinition definition) {
+ return addNonLegacyClass(definition.toReference());
+ }
+
+ public Builder addNonLegacyClass(SyntheticProgramClassReference reference) {
+ if (newNonLegacyClasses == null) {
+ newNonLegacyClasses = ImmutableMap.builder();
+ }
+ newNonLegacyClasses.put(reference.getHolder(), reference);
+ return this;
+ }
+
+ public Builder addNonLegacyMethod(SyntheticMethodDefinition definition) {
+ return addNonLegacyMethod(definition.toReference());
+ }
+
+ public Builder addNonLegacyMethod(SyntheticMethodReference reference) {
+ if (newNonLegacyMethods == null) {
+ newNonLegacyMethods = ImmutableMap.builder();
+ }
+ newNonLegacyMethods.put(reference.getHolder(), reference);
+ return this;
+ }
+
+ public Builder addLegacyClasses(Collection<DexProgramClass> classes) {
+ if (newLegacyClasses == null) {
+ newLegacyClasses = ImmutableSet.builder();
+ }
+ classes.forEach(c -> newLegacyClasses.add(c.getType()));
+ return this;
+ }
+
+ public Builder addLegacyClass(DexType type) {
+ if (newLegacyClasses == null) {
+ newLegacyClasses = ImmutableSet.builder();
+ }
+ newLegacyClasses.add(type);
+ return this;
+ }
+
+ public CommittedSyntheticsCollection build() {
+ if (newNonLegacyClasses == null && newNonLegacyMethods == null && newLegacyClasses == null) {
+ return parent;
+ }
+ ImmutableMap<DexType, SyntheticProgramClassReference> allNonLegacyClasses =
+ newNonLegacyClasses == null
+ ? parent.nonLegacyClasses
+ : newNonLegacyClasses.putAll(parent.nonLegacyClasses).build();
+ ImmutableMap<DexType, SyntheticMethodReference> allNonLegacyMethods =
+ newNonLegacyMethods == null
+ ? parent.nonLegacyMethods
+ : newNonLegacyMethods.putAll(parent.nonLegacyMethods).build();
+ ImmutableSet<DexType> allLegacyClasses =
+ newLegacyClasses == null
+ ? parent.legacyTypes
+ : newLegacyClasses.addAll(parent.legacyTypes).build();
+ return new CommittedSyntheticsCollection(
+ allLegacyClasses, allNonLegacyMethods, allNonLegacyClasses);
+ }
+ }
+
+ private static final CommittedSyntheticsCollection EMPTY =
+ new CommittedSyntheticsCollection(ImmutableSet.of(), ImmutableMap.of(), ImmutableMap.of());
+
+ /**
+ * Immutable set of synthetic types in the application (eg, committed).
+ *
+ * <p>TODO(b/158159959): Remove legacy support.
+ */
+ private final ImmutableSet<DexType> legacyTypes;
+
+ /** Mapping from synthetic type to its synthetic method item description. */
+ private final ImmutableMap<DexType, SyntheticMethodReference> nonLegacyMethods;
+
+ /** Mapping from synthetic type to its synthetic class item description. */
+ private final ImmutableMap<DexType, SyntheticProgramClassReference> nonLegacyClasses;
+
+ public CommittedSyntheticsCollection(
+ ImmutableSet<DexType> legacyTypes,
+ ImmutableMap<DexType, SyntheticMethodReference> nonLegacyMethods,
+ ImmutableMap<DexType, SyntheticProgramClassReference> nonLegacyClasses) {
+ this.legacyTypes = legacyTypes;
+ this.nonLegacyMethods = nonLegacyMethods;
+ this.nonLegacyClasses = nonLegacyClasses;
+ assert legacyTypes.size() + nonLegacyMethods.size() + nonLegacyClasses.size()
+ == Sets.union(Sets.union(nonLegacyMethods.keySet(), nonLegacyClasses.keySet()), legacyTypes)
+ .size();
+ }
+
+ public static CommittedSyntheticsCollection empty() {
+ return EMPTY;
+ }
+
+ Builder builder() {
+ return new Builder(this);
+ }
+
+ boolean isEmpty() {
+ return legacyTypes.isEmpty() && nonLegacyMethods.isEmpty() && nonLegacyClasses.isEmpty();
+ }
+
+ boolean containsType(DexType type) {
+ return containsLegacyType(type) || containsNonLegacyType(type);
+ }
+
+ public boolean containsLegacyType(DexType type) {
+ return legacyTypes.contains(type);
+ }
+
+ public boolean containsNonLegacyType(DexType type) {
+ return nonLegacyMethods.containsKey(type) || nonLegacyClasses.containsKey(type);
+ }
+
+ public ImmutableSet<DexType> getLegacyTypes() {
+ return legacyTypes;
+ }
+
+ public ImmutableMap<DexType, SyntheticMethodReference> getNonLegacyMethods() {
+ return nonLegacyMethods;
+ }
+
+ public ImmutableMap<DexType, SyntheticProgramClassReference> getNonLegacyClasses() {
+ return nonLegacyClasses;
+ }
+
+ public SyntheticReference<?, ?, ?> getNonLegacyItem(DexType type) {
+ SyntheticMethodReference reference = nonLegacyMethods.get(type);
+ if (reference != null) {
+ return reference;
+ }
+ return nonLegacyClasses.get(type);
+ }
+
+ public void forEachNonLegacyItem(Consumer<SyntheticReference<?, ?, ?>> fn) {
+ nonLegacyMethods.forEach((t, r) -> fn.accept(r));
+ nonLegacyClasses.forEach((t, r) -> fn.accept(r));
+ }
+
+ CommittedSyntheticsCollection pruneItems(PrunedItems prunedItems) {
+ Set<DexType> removed = prunedItems.getNoLongerSyntheticItems();
+ if (removed.isEmpty()) {
+ return this;
+ }
+ Builder builder = CommittedSyntheticsCollection.empty().builder();
+ boolean changed = false;
+ for (DexType type : legacyTypes) {
+ if (removed.contains(type)) {
+ changed = true;
+ } else {
+ builder.addLegacyClass(type);
+ }
+ }
+ for (SyntheticMethodReference reference : nonLegacyMethods.values()) {
+ if (removed.contains(reference.getHolder())) {
+ changed = true;
+ } else {
+ builder.addNonLegacyMethod(reference);
+ }
+ }
+ for (SyntheticProgramClassReference reference : nonLegacyClasses.values()) {
+ if (removed.contains(reference.getHolder())) {
+ changed = true;
+ } else {
+ builder.addNonLegacyClass(reference);
+ }
+ }
+ return changed ? builder.build() : this;
+ }
+
+ CommittedSyntheticsCollection rewriteWithLens(NonIdentityGraphLens lens) {
+ return new CommittedSyntheticsCollection(
+ lens.rewriteTypes(legacyTypes),
+ rewriteItems(nonLegacyMethods, lens),
+ rewriteItems(nonLegacyClasses, lens));
+ }
+
+ private static <R extends SyntheticReference<R, ?, ?>> ImmutableMap<DexType, R> rewriteItems(
+ Map<DexType, R> items, NonIdentityGraphLens lens) {
+ ImmutableMap.Builder<DexType, R> rewrittenItems = ImmutableMap.builder();
+ for (R reference : items.values()) {
+ R rewritten = reference.rewrite(lens);
+ if (rewritten != null) {
+ rewrittenItems.put(rewritten.getHolder(), rewritten);
+ }
+ }
+ return rewrittenItems.build();
+ }
+
+ boolean verifyTypesAreInApp(DexApplication application) {
+ assert verifyTypesAreInApp(application, legacyTypes);
+ assert verifyTypesAreInApp(application, nonLegacyMethods.keySet());
+ assert verifyTypesAreInApp(application, nonLegacyClasses.keySet());
+ return true;
+ }
+
+ private static boolean verifyTypesAreInApp(DexApplication app, Collection<DexType> types) {
+ for (DexType type : types) {
+ assert app.programDefinitionFor(type) != null : "Missing synthetic: " + type;
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
index f5d4b66..932359d 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.DescriptorUtils.getDescriptorFromClassBinaryName;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
@@ -14,6 +15,7 @@
import com.android.tools.r8.graph.ProgramDefinition;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.synthesis.SyntheticNaming.Phase;
import java.util.Comparator;
import java.util.Set;
@@ -38,6 +40,13 @@
private final DexType inputContextType;
private final Origin inputContextOrigin;
+ static SynthesizingContext fromNonSyntheticInputContext(DexClass context) {
+ // A context that is itself non-synthetic is the single context, thus both the input context
+ // and synthesizing context coincide.
+ return new SynthesizingContext(
+ context.getContextType(), context.getContextType(), context.getOrigin());
+ }
+
static SynthesizingContext fromNonSyntheticInputContext(ProgramDefinition context) {
// A context that is itself non-synthetic is the single context, thus both the input context
// and synthesizing context coincide.
@@ -53,6 +62,20 @@
return new SynthesizingContext(synthesizingContextType, clazz.type, clazz.origin);
}
+ static SynthesizingContext fromSyntheticContextChange(
+ DexType syntheticType, SynthesizingContext oldContext, DexItemFactory factory) {
+ String descriptor = syntheticType.toDescriptorString();
+ int i = descriptor.indexOf(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
+ if (i <= 0) {
+ assert false : "Unexpected synthetic without internal separator: " + syntheticType;
+ return null;
+ }
+ DexType newContext = factory.createType(descriptor.substring(0, i) + ";");
+ return newContext == oldContext.getSynthesizingContextType()
+ ? oldContext
+ : new SynthesizingContext(newContext, newContext, oldContext.inputContextOrigin);
+ }
+
private SynthesizingContext(
DexType synthesizingContextType, DexType inputContextType, Origin inputContextOrigin) {
this.synthesizingContextType = synthesizingContextType;
@@ -75,14 +98,6 @@
return inputContextOrigin;
}
- DexType createHygienicType(String syntheticId, DexItemFactory factory) {
- // If the context is a synthetic input, then use its annotated context as the hygienic context.
- String contextDesc = synthesizingContextType.toDescriptorString();
- String prefix = contextDesc.substring(0, contextDesc.length() - 1);
- String suffix = SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR + syntheticId + ";";
- return factory.createType(prefix + suffix);
- }
-
SynthesizingContext rewrite(NonIdentityGraphLens lens) {
DexType rewrittenInputeContextType = lens.lookupType(inputContextType);
DexType rewrittenSynthesizingContextType = lens.lookupType(synthesizingContextType);
@@ -127,15 +142,17 @@
void addIfDerivedFromMainDexClass(
DexProgramClass externalSyntheticClass,
MainDexClasses mainDexClasses,
- Set<DexType> allMainDexTypes,
- Set<DexType> derivedMainDexTypesToIgnore) {
+ Set<DexType> allMainDexTypes) {
// The input context type (not the annotated context) determines if the derived class is to be
// in main dex.
// TODO(b/168584485): Once resolved allMainDexTypes == mainDexClasses.
if (allMainDexTypes.contains(inputContextType)) {
mainDexClasses.add(externalSyntheticClass);
- // Mark the type as to be ignored when computing main-dex placement for legacy types.
- derivedMainDexTypesToIgnore.add(inputContextType);
}
}
+
+ @Override
+ public String toString() {
+ return "SynthesizingContext{" + getSynthesizingContextType() + "}";
+ }
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
index 4f289c7..01e6c75 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
@@ -1,16 +1,18 @@
// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
+
package com.android.tools.r8.synthesis;
import com.android.tools.r8.ProgramResource.Kind;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.graph.ClassKind;
import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.DexTypeList;
@@ -25,16 +27,20 @@
import java.util.List;
import java.util.function.Consumer;
-public class SyntheticClassBuilder {
+abstract class SyntheticClassBuilder<B extends SyntheticClassBuilder<B, C>, C extends DexClass> {
+
private final DexItemFactory factory;
private final DexType type;
private final Origin origin;
+ private Kind originKind;
private DexType superType;
private DexTypeList interfaces = DexTypeList.empty();
-
- private int nextMethodId = 0;
+ private List<DexEncodedField> staticFields = new ArrayList<>();
+ private List<DexEncodedField> instanceFields = new ArrayList<>();
+ private List<DexEncodedMethod> directMethods = new ArrayList<>();
+ private List<DexEncodedMethod> virtualMethods = new ArrayList<>();
private List<SyntheticMethodBuilder> methods = new ArrayList<>();
SyntheticClassBuilder(DexType type, SynthesizingContext context, DexItemFactory factory) {
@@ -44,6 +50,10 @@
this.superType = factory.objectType;
}
+ public abstract B self();
+
+ public abstract ClassKind<C> getClassKind();
+
public DexItemFactory getFactory() {
return factory;
}
@@ -52,67 +62,92 @@
return type;
}
- private String getNextMethodName() {
- return SyntheticItems.INTERNAL_SYNTHETIC_METHOD_PREFIX + nextMethodId++;
+ public B setInterfaces(List<DexType> interfaces) {
+ this.interfaces =
+ interfaces.isEmpty()
+ ? DexTypeList.empty()
+ : new DexTypeList(interfaces.toArray(DexType.EMPTY_ARRAY));
+ return self();
}
- public SyntheticClassBuilder addMethod(Consumer<SyntheticMethodBuilder> fn) {
- SyntheticMethodBuilder method = new SyntheticMethodBuilder(this, getNextMethodName());
+ public B setOriginKind(Kind originKind) {
+ this.originKind = originKind;
+ return self();
+ }
+
+ public B setStaticFields(List<DexEncodedField> fields) {
+ staticFields.clear();
+ staticFields.addAll(fields);
+ return self();
+ }
+
+ public B setInstanceFields(List<DexEncodedField> fields) {
+ instanceFields.clear();
+ instanceFields.addAll(fields);
+ return self();
+ }
+
+ public B setDirectMethods(Iterable<DexEncodedMethod> methods) {
+ directMethods.clear();
+ methods.forEach(directMethods::add);
+ return self();
+ }
+
+ public B setVirtualMethods(Iterable<DexEncodedMethod> methods) {
+ virtualMethods.clear();
+ methods.forEach(virtualMethods::add);
+ return self();
+ }
+
+ public B addMethod(Consumer<SyntheticMethodBuilder> fn) {
+ SyntheticMethodBuilder method = new SyntheticMethodBuilder(this);
fn.accept(method);
methods.add(method);
- return this;
+ return self();
}
- DexProgramClass build() {
+ public C build() {
ClassAccessFlags accessFlags =
- ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
- Kind originKind = null;
+ ClassAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_FINAL | Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
DexString sourceFile = null;
NestHostClassAttribute nestHost = null;
List<NestMemberClassAttribute> nestMembers = Collections.emptyList();
EnclosingMethodAttribute enclosingMembers = null;
List<InnerClassAttribute> innerClasses = Collections.emptyList();
- DexEncodedField[] staticFields = DexEncodedField.EMPTY_ARRAY;
- DexEncodedField[] instanceFields = DexEncodedField.EMPTY_ARRAY;
- DexEncodedMethod[] directMethods = DexEncodedMethod.EMPTY_ARRAY;
- DexEncodedMethod[] virtualMethods = DexEncodedMethod.EMPTY_ARRAY;
- assert !methods.isEmpty();
- List<DexEncodedMethod> directs = new ArrayList<>(methods.size());
- List<DexEncodedMethod> virtuals = new ArrayList<>(methods.size());
for (SyntheticMethodBuilder builder : methods) {
DexEncodedMethod method = builder.build();
if (method.isNonPrivateVirtualMethod()) {
- virtuals.add(method);
+ virtualMethods.add(method);
} else {
- directs.add(method);
+ directMethods.add(method);
}
}
- if (!directs.isEmpty()) {
- directMethods = directs.toArray(new DexEncodedMethod[directs.size()]);
- }
- if (!virtuals.isEmpty()) {
- virtualMethods = virtuals.toArray(new DexEncodedMethod[virtuals.size()]);
- }
- long checksum = 7 * (long) directs.hashCode() + 11 * (long) virtuals.hashCode();
- return new DexProgramClass(
- type,
- originKind,
- origin,
- accessFlags,
- superType,
- interfaces,
- sourceFile,
- nestHost,
- nestMembers,
- enclosingMembers,
- innerClasses,
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- staticFields,
- instanceFields,
- directMethods,
- virtualMethods,
- factory.getSkipNameValidationForTesting(),
- c -> checksum);
+ long checksum =
+ 7 * (long) directMethods.hashCode()
+ + 11 * (long) virtualMethods.hashCode()
+ + 13 * (long) staticFields.hashCode()
+ + 17 * (long) instanceFields.hashCode();
+ return getClassKind()
+ .create(
+ type,
+ originKind,
+ origin,
+ accessFlags,
+ superType,
+ interfaces,
+ sourceFile,
+ nestHost,
+ nestMembers,
+ enclosingMembers,
+ innerClasses,
+ ClassSignature.noSignature(),
+ DexAnnotationSet.empty(),
+ staticFields.toArray(DexEncodedField.EMPTY_ARRAY),
+ instanceFields.toArray(DexEncodedField.EMPTY_ARRAY),
+ directMethods.toArray(DexEncodedMethod.EMPTY_ARRAY),
+ virtualMethods.toArray(DexEncodedMethod.EMPTY_ARRAY),
+ factory.getSkipNameValidationForTesting(),
+ c -> checksum);
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java
new file mode 100644
index 0000000..3a915bf
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassDefinition.java
@@ -0,0 +1,47 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+
+/**
+ * Definition of a synthetic class item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+public abstract class SyntheticClassDefinition<
+ R extends SyntheticClassReference<R, D, C>,
+ D extends SyntheticClassDefinition<R, D, C>,
+ C extends DexClass>
+ extends SyntheticDefinition<R, D, C> {
+
+ final C clazz;
+
+ SyntheticClassDefinition(SyntheticKind kind, SynthesizingContext context, C clazz) {
+ super(kind, context);
+ this.clazz = clazz;
+ }
+
+ @Override
+ public final C getHolder() {
+ return clazz;
+ }
+
+ @Override
+ public boolean isValid() {
+ return clazz.isPublic() && clazz.isFinal() && clazz.accessFlags.isSynthetic();
+ }
+
+ @Override
+ public String toString() {
+ return "SyntheticClass{ clazz = "
+ + clazz.type.toSourceString()
+ + ", kind = "
+ + getKind()
+ + ", context = "
+ + getContext()
+ + " }";
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
new file mode 100644
index 0000000..25142ee
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+
+/**
+ * Reference to a synthetic class item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+abstract class SyntheticClassReference<
+ R extends SyntheticClassReference<R, D, C>,
+ D extends SyntheticClassDefinition<R, D, C>,
+ C extends DexClass>
+ extends SyntheticReference<R, D, C> {
+
+ final DexType type;
+
+ SyntheticClassReference(SyntheticKind kind, SynthesizingContext context, DexType type) {
+ super(kind, context);
+ this.type = type;
+ }
+
+ @Override
+ DexType getHolder() {
+ return type;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassBuilder.java
new file mode 100644
index 0000000..20cd075
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassBuilder.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.ProgramResource.Kind;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+
+public class SyntheticClasspathClassBuilder
+ extends SyntheticClassBuilder<SyntheticClasspathClassBuilder, DexClasspathClass> {
+
+ SyntheticClasspathClassBuilder(
+ DexType type, SynthesizingContext context, DexItemFactory factory) {
+ super(type, context, factory);
+ setOriginKind(Kind.CF);
+ }
+
+ @Override
+ public ClassKind<DexClasspathClass> getClassKind() {
+ return ClassKind.CLASSPATH;
+ }
+
+ @Override
+ public SyntheticClasspathClassBuilder self() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassDefinition.java
new file mode 100644
index 0000000..a05d505
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassDefinition.java
@@ -0,0 +1,66 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.android.tools.r8.utils.structural.RepresentativeMap;
+import com.google.common.hash.Hasher;
+
+/**
+ * Definition of a synthetic classpath class.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SyntheticClasspathClassDefinition
+ extends SyntheticClassDefinition<
+ SyntheticClasspathClassReference, SyntheticClasspathClassDefinition, DexClasspathClass>
+ implements SyntheticClasspathDefinition {
+
+ SyntheticClasspathClassDefinition(
+ SyntheticKind kind, SynthesizingContext context, DexClasspathClass clazz) {
+ super(kind, context, clazz);
+ }
+
+ @Override
+ public boolean isClasspathDefinition() {
+ return true;
+ }
+
+ @Override
+ public SyntheticClasspathDefinition asClasspathDefinition() {
+ return this;
+ }
+
+ @Override
+ SyntheticClasspathClassReference toReference() {
+ return new SyntheticClasspathClassReference(getKind(), getContext(), clazz.getType());
+ }
+
+ @Override
+ public boolean isValid() {
+ return clazz.isPublic() && clazz.isFinal() && clazz.accessFlags.isSynthetic();
+ }
+
+ @Override
+ void internalComputeHash(Hasher hasher, RepresentativeMap map) {
+ clazz.hashWithTypeEquivalence(hasher, map);
+ }
+
+ @Override
+ int internalCompareTo(SyntheticClasspathClassDefinition o, RepresentativeMap map) {
+ return clazz.compareWithTypeEquivalenceTo(o.clazz, map);
+ }
+
+ @Override
+ public String toString() {
+ return "SyntheticClasspathClass{ clazz = "
+ + clazz.type.toSourceString()
+ + ", kind = "
+ + getKind()
+ + ", context = "
+ + getContext()
+ + " }";
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java
new file mode 100644
index 0000000..5b9ba3c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import java.util.function.Function;
+
+/**
+ * Reference to a synthetic class item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SyntheticClasspathClassReference
+ extends SyntheticClassReference<
+ SyntheticClasspathClassReference, SyntheticClasspathClassDefinition, DexClasspathClass> {
+
+ SyntheticClasspathClassReference(SyntheticKind kind, SynthesizingContext context, DexType type) {
+ super(kind, context, type);
+ }
+
+ @Override
+ SyntheticClasspathClassDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
+ DexClass clazz = definitions.apply(type);
+ if (clazz == null) {
+ return null;
+ }
+ assert clazz.isClasspathClass();
+ return new SyntheticClasspathClassDefinition(getKind(), getContext(), clazz.asClasspathClass());
+ }
+
+ @Override
+ SyntheticClasspathClassReference rewrite(NonIdentityGraphLens lens) {
+ assert type == lens.lookupType(type)
+ : "Unexpected classpath rewrite of type " + type.toSourceString();
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathDefinition.java
new file mode 100644
index 0000000..0904dff
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathDefinition.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClasspathClass;
+
+public interface SyntheticClasspathDefinition {
+
+ DexClasspathClass getHolder();
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index 01f8825..071e7b6 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -3,31 +3,111 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.synthesis;
-import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.structural.RepresentativeMap;
import com.google.common.hash.HashCode;
+import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
/**
* Base type for the definition of a synthetic item.
*
* <p>This class is internal to the synthetic items collection, thus package-protected.
*/
-abstract class SyntheticDefinition {
+abstract class SyntheticDefinition<
+ R extends SyntheticReference<R, D, C>,
+ D extends SyntheticDefinition<R, D, C>,
+ C extends DexClass> {
+
+ private final SyntheticKind kind;
private final SynthesizingContext context;
- SyntheticDefinition(SynthesizingContext context) {
+ SyntheticDefinition(SyntheticKind kind, SynthesizingContext context) {
+ assert kind != null;
+ assert context != null;
+ this.kind = kind;
this.context = context;
}
- abstract SyntheticReference toReference();
+ public boolean isClasspathDefinition() {
+ return false;
+ }
- SynthesizingContext getContext() {
+ public SyntheticClasspathDefinition asClasspathDefinition() {
+ return null;
+ }
+
+ public boolean isProgramDefinition() {
+ return false;
+ }
+
+ public SyntheticProgramDefinition asProgramDefinition() {
+ return null;
+ }
+
+ abstract R toReference();
+
+ final SyntheticKind getKind() {
+ return kind;
+ }
+
+ final SynthesizingContext getContext() {
return context;
}
- abstract DexProgramClass getHolder();
+ public abstract C getHolder();
- abstract HashCode computeHash(RepresentativeMap map, boolean intermediate);
+ final HashCode computeHash(RepresentativeMap map, boolean intermediate) {
+ Hasher hasher = Hashing.murmur3_128().newHasher();
+ if (intermediate) {
+ // If in intermediate mode, include the context type as sharing is restricted to within a
+ // single context.
+ getContext().getSynthesizingContextType().hashWithTypeEquivalence(hasher, map);
+ }
+ internalComputeHash(hasher, map);
+ return hasher.hash();
+ }
- abstract boolean isEquivalentTo(SyntheticDefinition other, boolean intermediate);
+ abstract void internalComputeHash(Hasher hasher, RepresentativeMap map);
+
+ final boolean isEquivalentTo(D other, boolean includeContext, GraphLens graphLens) {
+ return compareTo(other, includeContext, graphLens) == 0;
+ }
+
+ int compareTo(D other, boolean includeContext, GraphLens graphLens) {
+ if (includeContext) {
+ int order = getContext().compareTo(other.getContext());
+ if (order != 0) {
+ return order;
+ }
+ }
+ DexType thisType = getHolder().getType();
+ DexType otherType = other.getHolder().getType();
+ RepresentativeMap map = null;
+ // If the synthetics have been moved include the original types in the equivalence.
+ if (graphLens.isNonIdentityLens()) {
+ DexType thisOrigType = graphLens.getOriginalType(thisType);
+ DexType otherOrigType = graphLens.getOriginalType(otherType);
+ if (thisType != thisOrigType || otherType != otherOrigType) {
+ map =
+ t -> {
+ if (t == otherType || t == thisOrigType || t == otherOrigType) {
+ return thisType;
+ }
+ return t;
+ };
+ }
+ }
+ if (map == null) {
+ map = t -> t == otherType ? thisType : t;
+ }
+ return internalCompareTo(other, map);
+ }
+
+ abstract int internalCompareTo(D other, RepresentativeMap map);
+
+ public abstract boolean isValid();
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index c18b29d..a802761 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -6,22 +6,32 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLens;
-import com.android.tools.r8.graph.GraphLens.Builder;
import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
import com.android.tools.r8.graph.PrunedItems;
+import com.android.tools.r8.graph.TreeFixerBase;
+import com.android.tools.r8.ir.code.NumberGenerator;
import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.collections.BidirectionalManyToManyRepresentativeMap;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeHashMap;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
+import com.android.tools.r8.utils.collections.BidirectionalOneToOneHashMap;
import com.android.tools.r8.utils.structural.RepresentativeMap;
import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Sets;
import com.google.common.hash.HashCode;
@@ -32,37 +42,147 @@
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;
-import java.util.function.Predicate;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
public class SyntheticFinalization {
public static class Result {
public final CommittedItems commit;
+ public final NonIdentityGraphLens lens;
public final PrunedItems prunedItems;
- public Result(CommittedItems commit, PrunedItems prunedItems) {
+ public Result(
+ CommittedItems commit, SyntheticFinalizationGraphLens lens, PrunedItems prunedItems) {
this.commit = commit;
+ this.lens = lens;
this.prunedItems = prunedItems;
}
}
- private static class EquivalenceGroup<T extends SyntheticDefinition & Comparable<T>>
- implements Comparable<EquivalenceGroup<T>> {
- private List<T> members;
+ public static class SyntheticFinalizationGraphLens extends NestedGraphLens {
- EquivalenceGroup(T singleton) {
- this(singleton, Collections.singletonList(singleton));
+ private final Map<DexType, DexType> syntheticTypeMap;
+ private final Map<DexMethod, DexMethod> syntheticMethodsMap;
+
+ private SyntheticFinalizationGraphLens(
+ GraphLens previous,
+ Map<DexType, DexType> syntheticClassesMap,
+ Map<DexMethod, DexMethod> syntheticMethodsMap,
+ Map<DexType, DexType> typeMap,
+ BidirectionalManyToOneRepresentativeMap<DexField, DexField> fieldMap,
+ Map<DexMethod, DexMethod> methodMap,
+ BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod> originalMethodSignatures,
+ DexItemFactory factory) {
+ super(typeMap, methodMap, fieldMap, originalMethodSignatures, previous, factory);
+ this.syntheticTypeMap = syntheticClassesMap;
+ this.syntheticMethodsMap = syntheticMethodsMap;
}
- EquivalenceGroup(T representative, List<T> members) {
+ // The mapping is many to one, so the inverse is only defined up to equivalence groups.
+ // Override the access to renamed signatures to first check for synthetic mappings before
+ // using the original item mappings of the
+
+ @Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ if (syntheticTypeMap.containsKey(originalField.holder)) {
+ DexField renamed = fieldMap.get(originalField);
+ if (renamed != null) {
+ return renamed;
+ }
+ }
+ return super.getRenamedFieldSignature(originalField);
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod, GraphLens applied) {
+ if (syntheticTypeMap.containsKey(originalMethod.holder)) {
+ DexMethod renamed = methodMap.get(originalMethod);
+ if (renamed != null) {
+ return renamed;
+ }
+ }
+ DexMethod renamed = syntheticMethodsMap.get(originalMethod);
+ return renamed != null ? renamed : super.getRenamedMethodSignature(originalMethod, applied);
+ }
+ }
+
+ private static class Builder {
+
+ // Forward mapping of internal to external synthetics.
+ Map<DexType, DexType> syntheticClassesMap = new IdentityHashMap<>();
+ Map<DexMethod, DexMethod> syntheticMethodsMap = new IdentityHashMap<>();
+
+ Map<DexType, DexType> typeMap = new IdentityHashMap<>();
+ BidirectionalManyToOneRepresentativeHashMap<DexField, DexField> fieldMap =
+ new BidirectionalManyToOneRepresentativeHashMap<>();
+ Map<DexMethod, DexMethod> methodMap = new IdentityHashMap<>();
+
+ protected final BidirectionalOneToOneHashMap<DexMethod, DexMethod> originalMethodSignatures =
+ new BidirectionalOneToOneHashMap<>();
+
+ void moveSyntheticClass(DexType from, DexType to) {
+ assert !syntheticClassesMap.containsKey(from);
+ syntheticClassesMap.put(from, to);
+ typeMap.put(from, to);
+ }
+
+ void moveSyntheticMethod(DexMethod from, DexMethod to) {
+ assert !syntheticMethodsMap.containsKey(from);
+ syntheticMethodsMap.put(from, to);
+ methodMap.put(from, to);
+ }
+
+ void move(DexType from, DexType to) {
+ typeMap.put(from, to);
+ }
+
+ void move(DexField from, DexField to) {
+ fieldMap.put(from, to);
+ }
+
+ void move(DexMethod from, DexMethod to) {
+ methodMap.put(from, to);
+ originalMethodSignatures.put(to, from);
+ }
+
+ SyntheticFinalizationGraphLens build(GraphLens previous, DexItemFactory factory) {
+ assert verifySubMap(syntheticClassesMap, typeMap);
+ if (typeMap.isEmpty() && fieldMap.isEmpty() && methodMap.isEmpty()) {
+ return null;
+ }
+ return new SyntheticFinalizationGraphLens(
+ previous,
+ syntheticClassesMap,
+ syntheticMethodsMap,
+ typeMap,
+ fieldMap,
+ methodMap,
+ originalMethodSignatures,
+ factory);
+ }
+
+ private static <K, V> boolean verifySubMap(Map<K, V> sub, Map<K, V> sup) {
+ for (Entry<K, V> entry : sub.entrySet()) {
+ assert sup.get(entry.getKey()) == entry.getValue();
+ }
+ return true;
+ }
+ }
+
+ public static class EquivalenceGroup<T extends SyntheticDefinition<?, T, ?>> {
+ private final List<T> members;
+
+ public EquivalenceGroup(T representative, List<T> members) {
assert !members.isEmpty();
assert members.get(0) == representative;
this.members = members;
}
- T getRepresentative() {
+ public T getRepresentative() {
return members.get(0);
}
@@ -70,89 +190,115 @@
return members;
}
+ public int compareToIncludingContext(EquivalenceGroup<T> other, GraphLens graphLens) {
+ return getRepresentative().compareTo(other.getRepresentative(), true, graphLens);
+ }
+
@Override
- public int compareTo(EquivalenceGroup<T> other) {
- return getRepresentative().compareTo(other.getRepresentative());
+ public String toString() {
+ return "EquivalenceGroup{ members = "
+ + members.size()
+ + ", repr = "
+ + getRepresentative()
+ + " }";
}
}
private final InternalOptions options;
- private final ImmutableSet<DexType> legacySyntheticTypes;
- private final ImmutableMap<DexType, SyntheticReference> syntheticItems;
+ private final CommittedSyntheticsCollection synthetics;
- SyntheticFinalization(
- InternalOptions options,
- ImmutableSet<DexType> legacySyntheticTypes,
- ImmutableMap<DexType, SyntheticReference> syntheticItems) {
+ SyntheticFinalization(InternalOptions options, CommittedSyntheticsCollection synthetics) {
this.options = options;
- this.legacySyntheticTypes = legacySyntheticTypes;
- this.syntheticItems = syntheticItems;
+ this.synthetics = synthetics;
}
public Result computeFinalSynthetics(AppView<?> appView) {
assert verifyNoNestedSynthetics();
- DexApplication application = appView.appInfo().app();
+ DexApplication application;
MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
- GraphLens graphLens = appView.graphLens();
-
- Map<DexType, SyntheticMethodDefinition> methodDefinitions =
- lookupSyntheticMethodDefinitions(application);
-
- Collection<List<SyntheticMethodDefinition>> potentialEquivalences =
- computePotentialEquivalences(methodDefinitions, options.intermediate);
-
- Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> equivalences =
- computeActualEquivalences(potentialEquivalences, options.intermediate, options.itemFactory);
-
- Builder lensBuilder = NestedGraphLens.builder();
- List<DexProgramClass> newProgramClasses = new ArrayList<>();
- List<DexProgramClass> finalSyntheticClasses = new ArrayList<>();
- Set<DexType> derivedMainDexTypesToIgnore = Sets.newIdentityHashSet();
- buildLensAndProgram(
- appView,
- equivalences,
- syntheticItems::containsKey,
- mainDexClasses,
- lensBuilder,
- newProgramClasses,
- finalSyntheticClasses,
- derivedMainDexTypesToIgnore);
-
- newProgramClasses.addAll(finalSyntheticClasses);
+ Builder lensBuilder = new Builder();
+ ImmutableMap.Builder<DexType, SyntheticMethodReference> finalMethodsBuilder =
+ ImmutableMap.builder();
+ ImmutableMap.Builder<DexType, SyntheticProgramClassReference> finalClassesBuilder =
+ ImmutableMap.builder();
+ List<DexProgramClass> finalSyntheticProgramDefinitions = new ArrayList<>();
+ {
+ Map<DexType, NumberGenerator> generators = new IdentityHashMap<>();
+ application =
+ buildLensAndProgram(
+ appView,
+ computeEquivalences(appView, synthetics.getNonLegacyMethods().values(), generators),
+ computeEquivalences(appView, synthetics.getNonLegacyClasses().values(), generators),
+ mainDexClasses,
+ lensBuilder,
+ (clazz, reference) -> {
+ finalSyntheticProgramDefinitions.add(clazz);
+ finalClassesBuilder.put(clazz.getType(), reference);
+ },
+ (clazz, reference) -> {
+ finalSyntheticProgramDefinitions.add(clazz);
+ finalMethodsBuilder.put(clazz.getType(), reference);
+ });
+ }
+ ImmutableMap<DexType, SyntheticMethodReference> finalMethods = finalMethodsBuilder.build();
+ ImmutableMap<DexType, SyntheticProgramClassReference> finalClasses =
+ finalClassesBuilder.build();
handleSynthesizedClassMapping(
- finalSyntheticClasses, application, options, mainDexClasses, derivedMainDexTypesToIgnore);
+ finalSyntheticProgramDefinitions,
+ application,
+ options,
+ mainDexClasses,
+ lensBuilder.typeMap);
- DexApplication app = application.builder().replaceProgramClasses(newProgramClasses).build();
-
- appView.setGraphLens(lensBuilder.build(options.itemFactory, graphLens));
assert appView.appInfo().getMainDexClasses() == mainDexClasses;
- Set<DexType> finalSyntheticTypes = Sets.newIdentityHashSet();
- finalSyntheticClasses.forEach(clazz -> finalSyntheticTypes.add(clazz.getType()));
-
Set<DexType> prunedSynthetics = Sets.newIdentityHashSet();
- for (DexType type : syntheticItems.keySet()) {
- if (!finalSyntheticTypes.contains(type)) {
- prunedSynthetics.add(type);
- }
- }
+ synthetics.forEachNonLegacyItem(
+ reference -> {
+ DexType type = reference.getHolder();
+ if (!finalMethods.containsKey(type) && !finalClasses.containsKey(type)) {
+ prunedSynthetics.add(type);
+ }
+ });
return new Result(
new CommittedItems(
SyntheticItems.INVALID_ID_AFTER_SYNTHETIC_FINALIZATION,
- app,
- legacySyntheticTypes,
- ImmutableMap.of(),
+ application,
+ new CommittedSyntheticsCollection(
+ synthetics.getLegacyTypes(), finalMethods, finalClasses),
ImmutableList.of()),
- PrunedItems.builder().setPrunedApp(app).addRemovedClasses(prunedSynthetics).build());
+ lensBuilder.build(appView.graphLens(), appView.dexItemFactory()),
+ PrunedItems.builder()
+ .setPrunedApp(application)
+ .addRemovedClasses(prunedSynthetics)
+ .build());
+ }
+
+ private <R extends SyntheticReference<R, D, ?>, D extends SyntheticDefinition<R, D, ?>>
+ Map<DexType, EquivalenceGroup<D>> computeEquivalences(
+ AppView<?> appView,
+ ImmutableCollection<R> references,
+ Map<DexType, NumberGenerator> generators) {
+ boolean intermediate = appView.options().intermediate;
+ Map<DexType, D> definitions = lookupDefinitions(appView, references);
+ Collection<List<D>> potentialEquivalences =
+ computePotentialEquivalences(
+ definitions, intermediate, appView.dexItemFactory(), appView.graphLens());
+ return computeActualEquivalences(potentialEquivalences, generators, appView, intermediate);
+ }
+
+ private boolean isNotSyntheticType(DexType type) {
+ return !synthetics.containsNonLegacyType(type);
}
private boolean verifyNoNestedSynthetics() {
// Check that a context is never itself synthetic class.
- for (SyntheticReference item : syntheticItems.values()) {
- assert !syntheticItems.containsKey(item.getContext().getSynthesizingContextType());
- }
+ synthetics.forEachNonLegacyItem(
+ item -> {
+ assert isNotSyntheticType(item.getContext().getSynthesizingContextType());
+ });
return true;
}
@@ -161,7 +307,7 @@
DexApplication application,
InternalOptions options,
MainDexClasses mainDexClasses,
- Set<DexType> derivedMainDexTypesToIgnore) {
+ Map<DexType, DexType> derivedMainDexTypesToIgnore) {
boolean includeSynthesizedClassMappingInOutput = shouldAnnotateSynthetics(options);
if (includeSynthesizedClassMappingInOutput) {
updateSynthesizedClassMapping(application, finalSyntheticClasses);
@@ -177,7 +323,7 @@
DexApplication application, List<DexProgramClass> finalSyntheticClasses) {
ListMultimap<DexProgramClass, DexProgramClass> originalToSynthesized =
ArrayListMultimap.create();
- for (DexType type : legacySyntheticTypes) {
+ for (DexType type : synthetics.getLegacyTypes()) {
DexProgramClass clazz = DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
if (clazz != null) {
for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
@@ -214,7 +360,7 @@
private void updateMainDexListWithSynthesizedClassMap(
DexApplication application,
MainDexClasses mainDexClasses,
- Set<DexType> derivedMainDexTypesToIgnore) {
+ Map<DexType, DexType> derivedMainDexTypesToIgnore) {
if (mainDexClasses.isEmpty()) {
return;
}
@@ -228,12 +374,11 @@
DexAnnotation.readAnnotationSynthesizedClassMap(
programClass, application.dexItemFactory);
for (DexType type : derived) {
- if (!derivedMainDexTypesToIgnore.contains(type)) {
- DexProgramClass syntheticClass =
- DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
- if (syntheticClass != null) {
- newMainDexClasses.add(syntheticClass);
- }
+ DexType mappedType = derivedMainDexTypesToIgnore.getOrDefault(type, type);
+ DexProgramClass syntheticClass =
+ DexProgramClass.asProgramClassOrNull(application.definitionFor(mappedType));
+ if (syntheticClass != null) {
+ newMainDexClasses.add(syntheticClass);
}
}
}
@@ -248,23 +393,17 @@
}
}
- private static void buildLensAndProgram(
+ private static DexApplication buildLensAndProgram(
AppView<?> appView,
Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> syntheticMethodGroups,
- Predicate<DexType> isSyntheticType,
+ Map<DexType, EquivalenceGroup<SyntheticProgramClassDefinition>> syntheticClassGroups,
MainDexClasses mainDexClasses,
Builder lensBuilder,
- List<DexProgramClass> normalClasses,
- List<DexProgramClass> newSyntheticClasses,
- Set<DexType> derivedMainDexTypesToIgnore) {
+ BiConsumer<DexProgramClass, SyntheticProgramClassReference> addFinalSyntheticClass,
+ BiConsumer<DexProgramClass, SyntheticMethodReference> addFinalSyntheticMethod) {
+ DexApplication application = appView.appInfo().app();
DexItemFactory factory = appView.dexItemFactory();
-
- for (DexProgramClass clazz : appView.appInfo().classes()) {
- if (!isSyntheticType.test(clazz.type)) {
- assert SyntheticItems.verifyNotInternalSynthetic(clazz.type);
- normalClasses.add(clazz);
- }
- }
+ List<DexProgramClass> newProgramClasses = new ArrayList<>();
// TODO(b/168584485): Remove this once class-mapping support is removed.
Set<DexType> derivedMainDexTypes = Sets.newIdentityHashSet();
@@ -280,60 +419,177 @@
}
});
+ Set<DexType> pruned = Sets.newIdentityHashSet();
syntheticMethodGroups.forEach(
(syntheticType, syntheticGroup) -> {
SyntheticMethodDefinition representative = syntheticGroup.getRepresentative();
SynthesizingContext context = representative.getContext();
context.registerPrefixRewriting(syntheticType, appView);
- SyntheticClassBuilder builder =
- new SyntheticClassBuilder(syntheticType, context, factory);
- // TODO(b/158159959): Support grouping multiple methods per synthetic class.
- builder.addMethod(
- methodBuilder -> {
- DexEncodedMethod definition = representative.getMethod().getDefinition();
- methodBuilder
- .setAccessFlags(definition.accessFlags)
- .setProto(definition.getProto())
- .setClassFileVersion(
- definition.hasClassFileVersion() ? definition.getClassFileVersion() : null)
- .setCode(m -> definition.getCode());
- });
- DexProgramClass externalSyntheticClass = builder.build();
- if (shouldAnnotateSynthetics(appView.options())) {
- externalSyntheticClass.setAnnotations(
- externalSyntheticClass
- .annotations()
- .getWithAddedOrReplaced(
- DexAnnotation.createAnnotationSynthesizedClass(
- context.getSynthesizingContextType(), factory)));
- }
+ DexProgramClass externalSyntheticClass =
+ createExternalMethodClass(syntheticType, representative, factory);
+ newProgramClasses.add(externalSyntheticClass);
+ addSyntheticMarker(representative.getKind(), externalSyntheticClass, context, appView);
assert externalSyntheticClass.getMethodCollection().size() == 1;
DexEncodedMethod externalSyntheticMethod =
externalSyntheticClass.methods().iterator().next();
- newSyntheticClasses.add(externalSyntheticClass);
for (SyntheticMethodDefinition member : syntheticGroup.getMembers()) {
- if (member.getMethod().getReference() != externalSyntheticMethod.method) {
- lensBuilder.map(member.getMethod().getReference(), externalSyntheticMethod.method);
- }
- member
- .getContext()
- .addIfDerivedFromMainDexClass(
- externalSyntheticClass,
- mainDexClasses,
- derivedMainDexTypes,
- derivedMainDexTypesToIgnore);
- // TODO(b/168584485): Remove this once class-mapping support is removed.
- DexProgramClass from =
- DexProgramClass.asProgramClassOrNull(
- appView
- .appInfo()
- .definitionForWithoutExistenceAssert(
- member.getContext().getSynthesizingContextType()));
- if (from != null) {
- externalSyntheticClass.addSynthesizedFrom(from);
+ DexMethod memberReference = member.getMethod().getReference();
+ pruned.add(member.getHolder().getType());
+ if (memberReference != externalSyntheticMethod.method) {
+ lensBuilder.moveSyntheticMethod(memberReference, externalSyntheticMethod.method);
}
}
});
+
+ List<DexProgramClass> deduplicatedClasses = new ArrayList<>();
+ syntheticClassGroups.forEach(
+ (syntheticType, syntheticGroup) -> {
+ SyntheticProgramClassDefinition representative = syntheticGroup.getRepresentative();
+ SynthesizingContext context = representative.getContext();
+ context.registerPrefixRewriting(syntheticType, appView);
+ DexProgramClass externalSyntheticClass = representative.getHolder();
+ newProgramClasses.add(externalSyntheticClass);
+ addSyntheticMarker(representative.getKind(), externalSyntheticClass, context, appView);
+ for (SyntheticProgramClassDefinition member : syntheticGroup.getMembers()) {
+ DexProgramClass memberClass = member.getHolder();
+ DexType memberType = memberClass.getType();
+ pruned.add(memberType);
+ if (memberType != syntheticType) {
+ lensBuilder.moveSyntheticClass(memberType, syntheticType);
+ }
+ // The aliasing of the non-representative members needs to be recorded manually.
+ if (member != representative) {
+ deduplicatedClasses.add(memberClass);
+ }
+ }
+ });
+
+ for (DexProgramClass clazz : application.classes()) {
+ if (!pruned.contains(clazz.type)) {
+ newProgramClasses.add(clazz);
+ }
+ }
+ application = application.builder().replaceProgramClasses(newProgramClasses).build();
+
+ // We can only assert that the method container classes are in here as the classes need
+ // to be rewritten by the tree-fixer.
+ for (DexType key : syntheticMethodGroups.keySet()) {
+ assert application.definitionFor(key) != null;
+ }
+
+ DexApplication.Builder<?> builder = application.builder();
+ TreeFixerBase treeFixer =
+ new TreeFixerBase(appView) {
+ @Override
+ public DexType mapClassType(DexType type) {
+ return lensBuilder.syntheticClassesMap.getOrDefault(type, type);
+ }
+
+ @Override
+ public void recordFieldChange(DexField from, DexField to) {
+ lensBuilder.move(from, to);
+ }
+
+ @Override
+ public void recordMethodChange(DexMethod from, DexMethod to) {
+ lensBuilder.move(from, to);
+ }
+
+ @Override
+ public void recordClassChange(DexType from, DexType to) {
+ lensBuilder.move(from, to);
+ }
+ };
+ treeFixer.fixupClasses(deduplicatedClasses);
+ builder.replaceProgramClasses(treeFixer.fixupClasses(application.classes()));
+ application = builder.build();
+
+ // Add the synthesized from after repackaging which changed class definitions.
+ final DexApplication appForLookup = application;
+ syntheticClassGroups.forEach(
+ (syntheticType, syntheticGroup) -> {
+ DexProgramClass externalSyntheticClass = appForLookup.programDefinitionFor(syntheticType);
+ addFinalSyntheticClass.accept(
+ externalSyntheticClass, syntheticGroup.getRepresentative().toReference());
+ for (SyntheticProgramClassDefinition member : syntheticGroup.getMembers()) {
+ addMainDexAndSynthesizedFromForMember(
+ member,
+ externalSyntheticClass,
+ mainDexClasses,
+ derivedMainDexTypes,
+ appForLookup::programDefinitionFor);
+ }
+ });
+ syntheticMethodGroups.forEach(
+ (syntheticType, syntheticGroup) -> {
+ DexProgramClass externalSyntheticClass = appForLookup.programDefinitionFor(syntheticType);
+ addFinalSyntheticMethod.accept(
+ externalSyntheticClass, syntheticGroup.getRepresentative().toReference());
+ for (SyntheticMethodDefinition member : syntheticGroup.getMembers()) {
+ addMainDexAndSynthesizedFromForMember(
+ member,
+ externalSyntheticClass,
+ mainDexClasses,
+ derivedMainDexTypes,
+ appForLookup::programDefinitionFor);
+ }
+ });
+
+ for (DexType key : syntheticMethodGroups.keySet()) {
+ assert application.definitionFor(key) != null;
+ }
+
+ for (DexType key : syntheticClassGroups.keySet()) {
+ assert application.definitionFor(key) != null;
+ }
+
+ return application;
+ }
+
+ private static void addSyntheticMarker(
+ SyntheticKind kind,
+ DexProgramClass externalSyntheticClass,
+ SynthesizingContext context,
+ AppView<?> appView) {
+ if (shouldAnnotateSynthetics(appView.options())) {
+ SyntheticMarker.addMarkerToClass(
+ externalSyntheticClass, kind, context, appView.dexItemFactory());
+ }
+ }
+
+ private static DexProgramClass createExternalMethodClass(
+ DexType syntheticType, SyntheticMethodDefinition representative, DexItemFactory factory) {
+ SyntheticProgramClassBuilder builder =
+ new SyntheticProgramClassBuilder(syntheticType, representative.getContext(), factory);
+ // TODO(b/158159959): Support grouping multiple methods per synthetic class.
+ builder.addMethod(
+ methodBuilder -> {
+ DexEncodedMethod definition = representative.getMethod().getDefinition();
+ methodBuilder
+ .setName(SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX)
+ .setAccessFlags(definition.accessFlags)
+ .setProto(definition.getProto())
+ .setClassFileVersion(
+ definition.hasClassFileVersion() ? definition.getClassFileVersion() : null)
+ .setCode(m -> definition.getCode());
+ });
+ return builder.build();
+ }
+
+ private static void addMainDexAndSynthesizedFromForMember(
+ SyntheticDefinition<?, ?, ?> member,
+ DexProgramClass externalSyntheticClass,
+ MainDexClasses mainDexClasses,
+ Set<DexType> derivedMainDexTypes,
+ Function<DexType, DexProgramClass> definitions) {
+ member
+ .getContext()
+ .addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexClasses, derivedMainDexTypes);
+ // TODO(b/168584485): Remove this once class-mapping support is removed.
+ DexProgramClass from = definitions.apply(member.getContext().getSynthesizingContextType());
+ if (from != null) {
+ externalSyntheticClass.addSynthesizedFrom(from);
+ }
}
private static boolean shouldAnnotateSynthetics(InternalOptions options) {
@@ -345,15 +601,18 @@
return options.intermediate && !options.cfToCfDesugar;
}
- private static <T extends SyntheticDefinition & Comparable<T>>
+ private <T extends SyntheticDefinition<?, T, ?>>
Map<DexType, EquivalenceGroup<T>> computeActualEquivalences(
- Collection<List<T>> potentialEquivalences, boolean intermediate, DexItemFactory factory) {
+ Collection<List<T>> potentialEquivalences,
+ Map<DexType, NumberGenerator> generators,
+ AppView<?> appView,
+ boolean intermediate) {
Map<DexType, List<EquivalenceGroup<T>>> groupsPerContext = new IdentityHashMap<>();
potentialEquivalences.forEach(
members -> {
- List<List<T>> groups = groupEquivalent(members, intermediate);
+ List<List<T>> groups = groupEquivalent(members, intermediate, appView.graphLens());
for (List<T> group : groups) {
- T representative = findDeterministicRepresentative(group);
+ T representative = findDeterministicRepresentative(group, appView.graphLens());
// The representative is required to be the first element of the group.
group.remove(representative);
group.add(0, representative);
@@ -368,27 +627,31 @@
Map<DexType, EquivalenceGroup<T>> equivalences = new IdentityHashMap<>();
groupsPerContext.forEach(
(context, groups) -> {
- groups.sort(EquivalenceGroup::compareTo);
+ // Sort the equivalence groups that go into 'context' including the context type of the
+ // representative which is equal to 'context' here (see assert below).
+ groups.sort((a, b) -> a.compareToIncludingContext(b, appView.graphLens()));
for (int i = 0; i < groups.size(); i++) {
EquivalenceGroup<T> group = groups.get(i);
+ assert group.getRepresentative().getContext().getSynthesizingContextType() == context;
// Two equivalence groups in same context type must be distinct otherwise the assignment
// of the synthetic name will be non-deterministic between the two.
- assert i == 0 || checkGroupsAreDistinct(groups.get(i - 1), group);
- DexType representativeType = createExternalType(context, i, factory);
+ assert i == 0 || checkGroupsAreDistinct(groups.get(i - 1), group, appView.graphLens());
+ SyntheticKind kind = group.members.get(0).getKind();
+ DexType representativeType = createExternalType(kind, context, generators, appView);
equivalences.put(representativeType, group);
}
});
return equivalences;
}
- private static <T extends SyntheticDefinition & Comparable<T>> List<List<T>> groupEquivalent(
- List<T> potentialEquivalence, boolean intermediate) {
+ private static <T extends SyntheticDefinition<?, T, ?>> List<List<T>> groupEquivalent(
+ List<T> potentialEquivalence, boolean intermediate, GraphLens graphLens) {
List<List<T>> groups = new ArrayList<>();
// Each other member is in a shared group if it is actually equivalent to the first member.
for (T synthetic : potentialEquivalence) {
boolean requireNewGroup = true;
for (List<T> group : groups) {
- if (synthetic.isEquivalentTo(group.get(0), intermediate)) {
+ if (synthetic.isEquivalentTo(group.get(0), intermediate, graphLens)) {
requireNewGroup = false;
group.add(synthetic);
break;
@@ -403,42 +666,78 @@
return groups;
}
- private static <T extends SyntheticDefinition & Comparable<T>> boolean checkGroupsAreDistinct(
- EquivalenceGroup<T> g1, EquivalenceGroup<T> g2) {
- assert g1.compareTo(g2) != 0;
+ private static <T extends SyntheticDefinition<?, T, ?>> boolean checkGroupsAreDistinct(
+ EquivalenceGroup<T> g1, EquivalenceGroup<T> g2, GraphLens graphLens) {
+ int order = g1.compareToIncludingContext(g2, graphLens);
+ assert order != 0;
+ assert order != g2.compareToIncludingContext(g1, graphLens);
return true;
}
- private static <T extends SyntheticDefinition & Comparable<T>> T findDeterministicRepresentative(
- List<T> members) {
+ private static <T extends SyntheticDefinition<?, T, ?>> T findDeterministicRepresentative(
+ List<T> members, GraphLens graphLens) {
// Pick a deterministic member as representative.
T smallest = members.get(0);
for (int i = 1; i < members.size(); i++) {
T next = members.get(i);
- if (next.compareTo(smallest) < 0) {
+ if (next.compareTo(smallest, true, graphLens) < 0) {
smallest = next;
}
}
return smallest;
}
- private static DexType createExternalType(
- DexType representativeContext, int nextContextId, DexItemFactory factory) {
- return factory.createType(
- DescriptorUtils.getDescriptorFromClassBinaryName(
- representativeContext.getInternalName()
- + SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR
- + nextContextId));
+ private DexType createExternalType(
+ SyntheticKind kind,
+ DexType representativeContext,
+ Map<DexType, NumberGenerator> generators,
+ AppView<?> appView) {
+ NumberGenerator generator =
+ generators.computeIfAbsent(representativeContext, k -> new NumberGenerator());
+ DexType externalType;
+ do {
+ externalType =
+ SyntheticNaming.createExternalType(
+ kind,
+ representativeContext,
+ Integer.toString(generator.next()),
+ appView.dexItemFactory());
+ DexClass clazz = appView.appInfo().definitionForWithoutExistenceAssert(externalType);
+ if (clazz != null && isNotSyntheticType(clazz.type)) {
+ assert options.testing.allowConflictingSyntheticTypes
+ : "Unexpected creation of an existing external synthetic type: " + clazz;
+ externalType = null;
+ }
+ } while (externalType == null);
+ return externalType;
}
- private static <T extends SyntheticDefinition> Collection<List<T>> computePotentialEquivalences(
- Map<DexType, T> definitions, boolean intermediate) {
+ private static <T extends SyntheticDefinition<?, T, ?>>
+ Collection<List<T>> computePotentialEquivalences(
+ Map<DexType, T> definitions,
+ boolean intermediate,
+ DexItemFactory factory,
+ GraphLens graphLens) {
if (definitions.isEmpty()) {
return Collections.emptyList();
}
- Set<DexType> allTypes = definitions.keySet();
- DexType representative = allTypes.iterator().next();
- RepresentativeMap map = t -> allTypes.contains(t) ? representative : t;
+ // Map all synthetic types to the java 'void' type. This is not an actual valid type, so it
+ // cannot collide with any valid java type providing a good hashing key for the synthetics.
+ Set<DexType> syntheticTypes;
+ if (graphLens.isIdentityLens()) {
+ syntheticTypes = definitions.keySet();
+ } else {
+ // If the synthetics are renamed include their original names in the equivalence too.
+ syntheticTypes = SetUtils.newIdentityHashSet(definitions.size() * 2);
+ definitions
+ .keySet()
+ .forEach(
+ t -> {
+ syntheticTypes.add(t);
+ syntheticTypes.add(graphLens.getOriginalType(t));
+ });
+ }
+ RepresentativeMap map = t -> syntheticTypes.contains(t) ? factory.voidType : t;
Map<HashCode, List<T>> equivalences = new HashMap<>(definitions.size());
for (T definition : definitions.values()) {
HashCode hash = definition.computeHash(map, intermediate);
@@ -447,25 +746,24 @@
return equivalences.values();
}
- private Map<DexType, SyntheticMethodDefinition> lookupSyntheticMethodDefinitions(
- DexApplication finalApp) {
- Map<DexType, SyntheticMethodDefinition> methods = new IdentityHashMap<>(syntheticItems.size());
- for (SyntheticReference reference : syntheticItems.values()) {
- SyntheticDefinition definition = reference.lookupDefinition(finalApp::definitionFor);
- if (definition == null || !(definition instanceof SyntheticMethodDefinition)) {
+ private <R extends SyntheticReference<R, D, ?>, D extends SyntheticDefinition<R, D, ?>>
+ Map<DexType, D> lookupDefinitions(AppView<?> appView, Collection<R> references) {
+ Map<DexType, D> definitions = new IdentityHashMap<>(references.size());
+ for (R reference : references) {
+ D definition = reference.lookupDefinition(appView::definitionFor);
+ if (definition == null) {
// We expect pruned definitions to have been removed.
assert false;
continue;
}
- SyntheticMethodDefinition method = (SyntheticMethodDefinition) definition;
- if (SyntheticMethodBuilder.isValidSyntheticMethod(method.getMethod().getDefinition())) {
- methods.put(method.getHolder().getType(), method);
+ if (definition.isValid()) {
+ definitions.put(reference.getHolder(), definition);
} else {
// Failing this check indicates that an optimization has modified the synthetic in a
// disruptive way.
assert false;
}
}
- return methods;
+ return definitions;
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index bc7d42e..657db43 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -6,12 +6,9 @@
import com.android.tools.r8.errors.InternalCompilerError;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexApplication;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexClasspathClass;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
@@ -21,11 +18,8 @@
import com.android.tools.r8.graph.PrunedItems;
import com.android.tools.r8.ir.conversion.MethodProcessingId;
import com.android.tools.r8.synthesis.SyntheticFinalization.Result;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSet.Builder;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -35,148 +29,114 @@
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.function.Predicate;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
public class SyntheticItems implements SyntheticDefinitionsProvider {
static final int INVALID_ID_AFTER_SYNTHETIC_FINALIZATION = -1;
- /**
- * The internal synthetic class separator is only used for representing synthetic items during
- * compilation. In particular, this separator must never be used to write synthetic classes to the
- * final compilation result.
- */
- public static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$InternalSynthetic";
-
- /**
- * The external synthetic class separator is used when writing classes. It may appear in types
- * during compilation as the output of a compilation may be the input to another.
- */
- public static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$ExternalSynthetic";
-
- /** Method prefix when generating synthetic methods in a class. */
- public static final String INTERNAL_SYNTHETIC_METHOD_PREFIX = "m";
-
- public static boolean verifyNotInternalSynthetic(DexType type) {
- assert !type.toDescriptorString().contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR);
- return true;
- }
-
/** Globally incremented id for the next internal synthetic class. */
private int nextSyntheticId;
- /**
- * Thread safe collection of synthesized classes that are not yet committed to the application.
- *
- * <p>TODO(b/158159959): Remove legacy support.
- */
- private final Map<DexType, DexProgramClass> legacyPendingClasses = new ConcurrentHashMap<>();
+ /** Collection of pending items. */
+ private static class PendingSynthetics {
+ /**
+ * Thread safe collection of synthesized classes that are not yet committed to the application.
+ *
+ * <p>TODO(b/158159959): Remove legacy support.
+ */
+ private final Map<DexType, DexProgramClass> legacyClasses = new ConcurrentHashMap<>();
- /**
- * Immutable set of synthetic types in the application (eg, committed).
- *
- * <p>TODO(b/158159959): Remove legacy support.
- */
- private final ImmutableSet<DexType> legacySyntheticTypes;
+ /** Thread safe collection of synthetic items not yet committed to the application. */
+ private final ConcurrentHashMap<DexType, SyntheticDefinition<?, ?, ?>> nonLegacyDefinitions =
+ new ConcurrentHashMap<>();
- /** Thread safe collection of synthetic items not yet committed to the application. */
- private final ConcurrentHashMap<DexType, SyntheticDefinition> pendingDefinitions =
- new ConcurrentHashMap<>();
+ boolean isEmpty() {
+ return legacyClasses.isEmpty() && nonLegacyDefinitions.isEmpty();
+ }
- /** Mapping from synthetic type to its synthetic description. */
- private final ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems;
+ boolean containsType(DexType type) {
+ return legacyClasses.containsKey(type) || nonLegacyDefinitions.containsKey(type);
+ }
+
+ boolean verifyNotRewritten(NonIdentityGraphLens lens) {
+ assert legacyClasses.keySet().equals(lens.rewriteTypes(legacyClasses.keySet()));
+ assert nonLegacyDefinitions.keySet().equals(lens.rewriteTypes(nonLegacyDefinitions.keySet()));
+ return true;
+ }
+
+ Collection<DexProgramClass> getAllProgramClasses() {
+ List<DexProgramClass> allPending =
+ new ArrayList<>(nonLegacyDefinitions.size() + legacyClasses.size());
+ for (SyntheticDefinition<?, ?, ?> item : nonLegacyDefinitions.values()) {
+ if (item.isProgramDefinition()) {
+ allPending.add(item.asProgramDefinition().getHolder());
+ }
+ }
+ allPending.addAll(legacyClasses.values());
+ return Collections.unmodifiableList(allPending);
+ }
+ }
+
+ private final CommittedSyntheticsCollection committed;
+
+ private final PendingSynthetics pending = new PendingSynthetics();
// Only for use from initial AppInfo/AppInfoWithClassHierarchy create functions. */
public static CommittedItems createInitialSyntheticItems(DexApplication application) {
return new CommittedItems(
- 0, application, ImmutableSet.of(), ImmutableMap.of(), ImmutableList.of());
+ 0, application, CommittedSyntheticsCollection.empty(), ImmutableList.of());
}
// Only for conversion to a mutable synthetic items collection.
SyntheticItems(CommittedItems commit) {
- this(commit.nextSyntheticId, commit.legacySyntheticTypes, commit.syntheticItems);
+ this(commit.nextSyntheticId, commit.committed);
}
- private SyntheticItems(
- int nextSyntheticId,
- ImmutableSet<DexType> legacySyntheticTypes,
- ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems) {
+ private SyntheticItems(int nextSyntheticId, CommittedSyntheticsCollection committed) {
this.nextSyntheticId = nextSyntheticId;
- this.legacySyntheticTypes = legacySyntheticTypes;
- this.nonLecacySyntheticItems = nonLecacySyntheticItems;
- assert Sets.intersection(nonLecacySyntheticItems.keySet(), legacySyntheticTypes).isEmpty();
+ this.committed = committed;
}
public static void collectSyntheticInputs(AppView<AppInfo> appView) {
// Collecting synthetic items must be the very first task after application build.
SyntheticItems synthetics = appView.getSyntheticItems();
assert synthetics.nextSyntheticId == 0;
- assert synthetics.nonLecacySyntheticItems.isEmpty();
- assert !synthetics.hasPendingSyntheticClasses();
+ assert synthetics.committed.isEmpty();
+ assert synthetics.pending.isEmpty();
if (appView.options().intermediate) {
// If the compilation is in intermediate mode the synthetics should just be passed through.
return;
}
- ImmutableMap.Builder<DexType, SyntheticReference> pending = ImmutableMap.builder();
+ CommittedSyntheticsCollection.Builder builder = synthetics.committed.builder();
// TODO(b/158159959): Consider identifying synthetics in the input reader to speed this up.
for (DexProgramClass clazz : appView.appInfo().classes()) {
- DexType annotatedContextType = isSynthesizedMethodsContainer(clazz, appView.dexItemFactory());
- if (annotatedContextType == null) {
- continue;
+ SyntheticMarker marker =
+ SyntheticMarker.stripMarkerFromClass(clazz, appView.dexItemFactory());
+ if (marker.isSyntheticMethods()) {
+ clazz.forEachProgramMethod(
+ // TODO(b/158159959): Support having multiple methods per class.
+ method -> {
+ builder.addNonLegacyMethod(
+ new SyntheticMethodDefinition(marker.getKind(), marker.getContext(), method));
+ });
+ } else if (marker.isSyntheticClass()) {
+ builder.addNonLegacyClass(
+ new SyntheticProgramClassDefinition(marker.getKind(), marker.getContext(), clazz));
}
- clazz.setAnnotations(DexAnnotationSet.empty());
- SynthesizingContext context =
- SynthesizingContext.fromSyntheticInputClass(clazz, annotatedContextType);
- clazz.forEachProgramMethod(
- // TODO(b/158159959): Support having multiple methods per class.
- method -> {
- method.getDefinition().setAnnotations(DexAnnotationSet.empty());
- pending.put(clazz.type, new SyntheticMethodDefinition(context, method).toReference());
- });
}
- pending.putAll(synthetics.nonLecacySyntheticItems);
- ImmutableMap<DexType, SyntheticReference> nonLegacySyntheticItems = pending.build();
- if (nonLegacySyntheticItems.isEmpty()) {
+ CommittedSyntheticsCollection committed = builder.build();
+ if (committed.isEmpty()) {
return;
}
CommittedItems commit =
new CommittedItems(
- synthetics.nextSyntheticId,
- appView.appInfo().app(),
- synthetics.legacySyntheticTypes,
- nonLegacySyntheticItems,
- ImmutableList.of());
+ synthetics.nextSyntheticId, appView.appInfo().app(), committed, ImmutableList.of());
appView.setAppInfo(new AppInfo(commit, appView.appInfo().getMainDexClasses()));
}
- private static DexType isSynthesizedMethodsContainer(
- DexProgramClass clazz, DexItemFactory factory) {
- ClassAccessFlags flags = clazz.accessFlags;
- if (!flags.isSynthetic() || flags.isAbstract() || flags.isEnum()) {
- return null;
- }
- DexType contextType =
- DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory);
- if (contextType == null) {
- return null;
- }
- if (clazz.superType != factory.objectType) {
- return null;
- }
- if (!clazz.interfaces.isEmpty()) {
- return null;
- }
- if (clazz.annotations().size() != 1) {
- return null;
- }
- for (DexEncodedMethod method : clazz.methods()) {
- if (!SyntheticMethodBuilder.isValidSyntheticMethod(method)) {
- return null;
- }
- }
- return contextType;
- }
-
// Internal synthetic id creation helpers.
private synchronized String getNextSyntheticId() {
@@ -191,49 +151,54 @@
@Override
public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
- DexProgramClass pending = legacyPendingClasses.get(type);
- if (pending == null) {
- SyntheticDefinition item = pendingDefinitions.get(type);
+ DexClass clazz = pending.legacyClasses.get(type);
+ if (clazz == null) {
+ SyntheticDefinition<?, ?, ?> item = pending.nonLegacyDefinitions.get(type);
if (item != null) {
- pending = item.getHolder();
+ clazz = item.getHolder();
+ assert clazz.isProgramClass() == item.isProgramDefinition();
+ assert clazz.isClasspathClass() == item.isClasspathDefinition();
}
}
- if (pending != null) {
+ if (clazz != null) {
assert baseDefinitionFor.apply(type) == null
: "Pending synthetic definition also present in the active program: " + type;
- return pending;
+ return clazz;
}
return baseDefinitionFor.apply(type);
}
+ public boolean verifyNonLegacySyntheticsAreCommitted() {
+ assert pending.nonLegacyDefinitions.isEmpty()
+ : "Uncommitted synthetics: "
+ + pending.nonLegacyDefinitions.keySet().stream()
+ .map(DexType::getName)
+ .collect(Collectors.joining(", "));
+ return true;
+ }
+
public boolean hasPendingSyntheticClasses() {
- return !legacyPendingClasses.isEmpty() || !pendingDefinitions.isEmpty();
+ return !pending.isEmpty();
}
public Collection<DexProgramClass> getPendingSyntheticClasses() {
- List<DexProgramClass> pending =
- new ArrayList<>(pendingDefinitions.size() + legacyPendingClasses.size());
- for (SyntheticDefinition item : pendingDefinitions.values()) {
- pending.add(item.getHolder());
- }
- pending.addAll(legacyPendingClasses.values());
- return Collections.unmodifiableList(pending);
+ return pending.getAllProgramClasses();
}
private boolean isCommittedSynthetic(DexType type) {
- return nonLecacySyntheticItems.containsKey(type) || legacySyntheticTypes.contains(type);
+ return committed.containsType(type);
}
private boolean isLegacyCommittedSynthetic(DexType type) {
- return legacySyntheticTypes.contains(type);
+ return committed.containsLegacyType(type);
}
public boolean isPendingSynthetic(DexType type) {
- return pendingDefinitions.containsKey(type) || legacyPendingClasses.containsKey(type);
+ return pending.containsType(type);
}
public boolean isLegacyPendingSynthetic(DexType type) {
- return legacyPendingClasses.containsKey(type);
+ return pending.legacyClasses.containsKey(type);
}
public boolean isSyntheticClass(DexType type) {
@@ -247,6 +212,27 @@
return isSyntheticClass(clazz.type);
}
+ // The compiler should not inspect the kind of a synthetic, so this provided only as a assertion
+ // utility.
+ public boolean verifySyntheticLambdaProperty(
+ DexProgramClass clazz,
+ Predicate<DexProgramClass> ifIsLambda,
+ Predicate<DexProgramClass> ifNotLambda) {
+ SyntheticReference<?, ?, ?> reference = committed.getNonLegacyItem(clazz.getType());
+ if (reference == null) {
+ SyntheticDefinition<?, ?, ?> definition = pending.nonLegacyDefinitions.get(clazz.getType());
+ if (definition != null) {
+ reference = definition.toReference();
+ }
+ }
+ if (reference != null && reference.getKind() == SyntheticKind.LAMBDA) {
+ assert ifIsLambda.test(clazz);
+ } else {
+ assert ifNotLambda.test(clazz);
+ }
+ return true;
+ }
+
public boolean isLegacySyntheticClass(DexType type) {
return isLegacyCommittedSynthetic(type) || isLegacyPendingSynthetic(type);
}
@@ -256,18 +242,21 @@
}
public Collection<DexProgramClass> getLegacyPendingClasses() {
- return Collections.unmodifiableCollection(legacyPendingClasses.values());
+ return Collections.unmodifiableCollection(pending.legacyClasses.values());
}
private SynthesizingContext getSynthesizingContext(ProgramDefinition context) {
- SyntheticDefinition pendingItemContext = pendingDefinitions.get(context.getContextType());
- if (pendingItemContext != null) {
- return pendingItemContext.getContext();
+ DexType contextType = context.getContextType();
+ SyntheticDefinition<?, ?, ?> existingDefinition = pending.nonLegacyDefinitions.get(contextType);
+ if (existingDefinition != null) {
+ return existingDefinition.getContext();
}
- SyntheticReference committedItemContext = nonLecacySyntheticItems.get(context.getContextType());
- return committedItemContext != null
- ? committedItemContext.getContext()
- : SynthesizingContext.fromNonSyntheticInputContext(context);
+ SyntheticReference<?, ?, ?> existingReference = committed.getNonLegacyItem(contextType);
+ if (existingReference != null) {
+ return existingReference.getContext();
+ }
+ // This context is not nested in an existing synthetic context so create a new "leaf" context.
+ return SynthesizingContext.fromNonSyntheticInputContext(context);
}
// Addition and creation of synthetic items.
@@ -276,25 +265,71 @@
public void addLegacySyntheticClass(DexProgramClass clazz) {
assert clazz.type.isD8R8SynthesizedClassType();
assert !isCommittedSynthetic(clazz.type);
- DexProgramClass previous = legacyPendingClasses.put(clazz.type, clazz);
+ assert !pending.nonLegacyDefinitions.containsKey(clazz.type);
+ DexProgramClass previous = pending.legacyClasses.put(clazz.type, clazz);
assert previous == null || previous == clazz;
}
+ public DexProgramClass createClass(
+ SyntheticKind kind,
+ DexProgramClass context,
+ DexItemFactory factory,
+ Supplier<String> syntheticIdSupplier,
+ Consumer<SyntheticProgramClassBuilder> fn) {
+ // Obtain the outer synthesizing context in the case the context itself is synthetic.
+ // This is to ensure a flat input-type -> synthetic-item mapping.
+ SynthesizingContext outerContext = getSynthesizingContext(context);
+ DexType type =
+ SyntheticNaming.createInternalType(kind, outerContext, syntheticIdSupplier.get(), factory);
+ SyntheticProgramClassBuilder classBuilder =
+ new SyntheticProgramClassBuilder(type, outerContext, factory);
+ fn.accept(classBuilder);
+ DexProgramClass clazz = classBuilder.build();
+ addPendingDefinition(new SyntheticProgramClassDefinition(kind, outerContext, clazz));
+ return clazz;
+ }
+
+ public DexClasspathClass createClasspathClass(
+ SyntheticKind kind, DexType type, DexClass context, DexItemFactory factory) {
+ // Obtain the outer synthesizing context in the case the context itself is synthetic.
+ // This is to ensure a flat input-type -> synthetic-item mapping.
+ SynthesizingContext outerContext = SynthesizingContext.fromNonSyntheticInputContext(context);
+ SyntheticClasspathClassBuilder classBuilder =
+ new SyntheticClasspathClassBuilder(type, outerContext, factory);
+ DexClasspathClass clazz = classBuilder.build();
+ addPendingDefinition(new SyntheticClasspathClassDefinition(kind, outerContext, clazz));
+ return clazz;
+ }
+
/** Create a single synthetic method item. */
public ProgramMethod createMethod(
- ProgramDefinition context, DexItemFactory factory, Consumer<SyntheticMethodBuilder> fn) {
- return createMethod(context, factory, fn, this::getNextSyntheticId);
+ SyntheticKind kind,
+ ProgramDefinition context,
+ DexItemFactory factory,
+ Consumer<SyntheticMethodBuilder> fn) {
+ return createMethod(kind, context, factory, fn, this::getNextSyntheticId);
}
+ // TODO(b/172194101): Remove this once the uniqueness is a property of the context.
public ProgramMethod createMethod(
+ SyntheticKind kind,
ProgramDefinition context,
DexItemFactory factory,
Consumer<SyntheticMethodBuilder> fn,
MethodProcessingId methodProcessingId) {
- return createMethod(context, factory, fn, methodProcessingId::getFullyQualifiedIdAndIncrement);
+ return createMethod(
+ kind,
+ context,
+ factory,
+ fn,
+ methodProcessingId != null
+ ? methodProcessingId::getFullyQualifiedIdAndIncrement
+ : this::getNextSyntheticId);
}
- private ProgramMethod createMethod(
+ // TODO(b/172194101): Remove/private this once the uniqueness is a property of the context.
+ public ProgramMethod createMethod(
+ SyntheticKind kind,
ProgramDefinition context,
DexItemFactory factory,
Consumer<SyntheticMethodBuilder> fn,
@@ -303,16 +338,21 @@
// Obtain the outer synthesizing context in the case the context itself is synthetic.
// This is to ensure a flat input-type -> synthetic-item mapping.
SynthesizingContext outerContext = getSynthesizingContext(context);
- DexType type = outerContext.createHygienicType(syntheticIdSupplier.get(), factory);
- SyntheticClassBuilder classBuilder = new SyntheticClassBuilder(type, outerContext, factory);
- DexProgramClass clazz = classBuilder.addMethod(fn).build();
+ DexType type =
+ SyntheticNaming.createInternalType(kind, outerContext, syntheticIdSupplier.get(), factory);
+ SyntheticProgramClassBuilder classBuilder =
+ new SyntheticProgramClassBuilder(type, outerContext, factory);
+ DexProgramClass clazz =
+ classBuilder
+ .addMethod(fn.andThen(m -> m.setName(SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX)))
+ .build();
ProgramMethod method = new ProgramMethod(clazz, clazz.methods().iterator().next());
- addPendingDefinition(new SyntheticMethodDefinition(outerContext, method));
+ addPendingDefinition(new SyntheticMethodDefinition(kind, outerContext, method));
return method;
}
- private void addPendingDefinition(SyntheticDefinition definition) {
- pendingDefinitions.put(definition.getHolder().getType(), definition);
+ private void addPendingDefinition(SyntheticDefinition<?, ?, ?> definition) {
+ pending.nonLegacyDefinitions.put(definition.getHolder().getType(), definition);
}
// Commit of the synthetic items to a new fully populated application.
@@ -322,125 +362,56 @@
}
public CommittedItems commitPrunedItems(PrunedItems prunedItems) {
- return commit(
- prunedItems.getPrunedApp(),
- prunedItems.getNoLongerSyntheticItems(),
- legacyPendingClasses,
- legacySyntheticTypes,
- pendingDefinitions,
- nonLecacySyntheticItems,
- nextSyntheticId);
+ return commit(prunedItems, pending, committed, nextSyntheticId);
}
public CommittedItems commitRewrittenWithLens(
DexApplication application, NonIdentityGraphLens lens) {
- // Rewrite the previously committed synthetic types.
- ImmutableSet<DexType> rewrittenLegacyTypes = lens.rewriteTypes(this.legacySyntheticTypes);
- ImmutableMap.Builder<DexType, SyntheticReference> rewrittenItems = ImmutableMap.builder();
- for (SyntheticReference reference : nonLecacySyntheticItems.values()) {
- SyntheticReference rewritten = reference.rewrite(lens);
- if (rewritten != null) {
- rewrittenItems.put(rewritten.getHolder(), rewritten);
- }
- }
- // No pending item should need rewriting.
- assert legacyPendingClasses.keySet().equals(lens.rewriteTypes(legacyPendingClasses.keySet()));
- assert pendingDefinitions.keySet().equals(lens.rewriteTypes(pendingDefinitions.keySet()));
+ assert pending.verifyNotRewritten(lens);
return commit(
- application,
- Collections.emptySet(),
- legacyPendingClasses,
- rewrittenLegacyTypes,
- pendingDefinitions,
- rewrittenItems.build(),
- nextSyntheticId);
+ PrunedItems.empty(application), pending, committed.rewriteWithLens(lens), nextSyntheticId);
}
private static CommittedItems commit(
- DexApplication application,
- Set<DexType> removedClasses,
- Map<DexType, DexProgramClass> legacyPendingClasses,
- ImmutableSet<DexType> legacySyntheticTypes,
- ConcurrentHashMap<DexType, SyntheticDefinition> pendingDefinitions,
- ImmutableMap<DexType, SyntheticReference> syntheticItems,
+ PrunedItems prunedItems,
+ PendingSynthetics pending,
+ CommittedSyntheticsCollection committed,
int nextSyntheticId) {
- // Legacy synthetics must already have been committed.
- assert verifyClassesAreInApp(application, legacyPendingClasses.values());
- // Add the set of legacy definitions to the synthetic types.
- ImmutableSet<DexType> mergedLegacyTypes = legacySyntheticTypes;
- if (!legacyPendingClasses.isEmpty() || !removedClasses.isEmpty()) {
- ImmutableSet.Builder<DexType> legacyBuilder = ImmutableSet.builder();
- filteredAdd(legacySyntheticTypes, removedClasses, legacyBuilder);
- filteredAdd(legacyPendingClasses.keySet(), removedClasses, legacyBuilder);
- mergedLegacyTypes = legacyBuilder.build();
- }
- // The set of synthetic items is the union of the previous types plus the pending additions.
- ImmutableMap<DexType, SyntheticReference> mergedItems;
- ImmutableList<DexType> additions;
+ DexApplication application = prunedItems.getPrunedApp();
+ Set<DexType> removedClasses = prunedItems.getNoLongerSyntheticItems();
+ CommittedSyntheticsCollection.Builder builder = committed.builder();
+ // Legacy synthetics must already have been committed to the app.
+ assert verifyClassesAreInApp(application, pending.legacyClasses.values());
+ builder.addLegacyClasses(pending.legacyClasses.values());
+ // Compute the synthetic additions and add them to the application.
+ ImmutableList<DexType> committedProgramTypes;
DexApplication amendedApplication;
- if (pendingDefinitions.isEmpty()) {
- mergedItems = filteredCopy(syntheticItems, removedClasses);
- additions = ImmutableList.of();
+ if (pending.nonLegacyDefinitions.isEmpty()) {
+ committedProgramTypes = ImmutableList.of();
amendedApplication = application;
} else {
DexApplication.Builder<?> appBuilder = application.builder();
- ImmutableMap.Builder<DexType, SyntheticReference> itemsBuilder = ImmutableMap.builder();
- ImmutableList.Builder<DexType> additionsBuilder = ImmutableList.builder();
- for (SyntheticDefinition definition : pendingDefinitions.values()) {
- if (removedClasses.contains(definition.getHolder().getType())) {
- continue;
+ ImmutableList.Builder<DexType> committedProgramTypesBuilder = ImmutableList.builder();
+ for (SyntheticDefinition<?, ?, ?> definition : pending.nonLegacyDefinitions.values()) {
+ if (!removedClasses.contains(definition.getHolder().getType())) {
+ if (definition.isProgramDefinition()) {
+ committedProgramTypesBuilder.add(definition.getHolder().getType());
+ appBuilder.addProgramClass(definition.asProgramDefinition().getHolder());
+ } else {
+ assert definition.isClasspathDefinition();
+ appBuilder.addClasspathClass(definition.asClasspathDefinition().getHolder());
+ }
+ builder.addItem(definition);
}
- SyntheticReference reference = definition.toReference();
- itemsBuilder.put(reference.getHolder(), reference);
- additionsBuilder.add(definition.getHolder().getType());
- appBuilder.addProgramClass(definition.getHolder());
}
- filteredAdd(syntheticItems, removedClasses, itemsBuilder);
- mergedItems = itemsBuilder.build();
- additions = additionsBuilder.build();
+ committedProgramTypes = committedProgramTypesBuilder.build();
amendedApplication = appBuilder.build();
}
return new CommittedItems(
- nextSyntheticId, amendedApplication, mergedLegacyTypes, mergedItems, additions);
- }
-
- private static void filteredAdd(
- Set<DexType> input, Set<DexType> excludeSet, Builder<DexType> result) {
- if (excludeSet.isEmpty()) {
- result.addAll(input);
- } else {
- for (DexType type : input) {
- if (!excludeSet.contains(type)) {
- result.add(type);
- }
- }
- }
- }
-
- private static ImmutableMap<DexType, SyntheticReference> filteredCopy(
- ImmutableMap<DexType, SyntheticReference> syntheticItems, Set<DexType> removedClasses) {
- if (removedClasses.isEmpty()) {
- return syntheticItems;
- }
- ImmutableMap.Builder<DexType, SyntheticReference> builder = ImmutableMap.builder();
- filteredAdd(syntheticItems, removedClasses, builder);
- return builder.build();
- }
-
- private static void filteredAdd(
- ImmutableMap<DexType, SyntheticReference> syntheticItems,
- Set<DexType> removedClasses,
- ImmutableMap.Builder<DexType, SyntheticReference> builder) {
- if (removedClasses.isEmpty()) {
- builder.putAll(syntheticItems);
- } else {
- syntheticItems.forEach(
- (t, r) -> {
- if (!removedClasses.contains(t)) {
- builder.put(t, r);
- }
- });
- }
+ nextSyntheticId,
+ amendedApplication,
+ builder.build().pruneItems(prunedItems),
+ committedProgramTypes);
}
private static boolean verifyClassesAreInApp(
@@ -455,8 +426,6 @@
public Result computeFinalSynthetics(AppView<?> appView) {
assert !hasPendingSyntheticClasses();
- return new SyntheticFinalization(
- appView.options(), legacySyntheticTypes, nonLecacySyntheticItems)
- .computeFinalSynthetics(appView);
+ return new SyntheticFinalization(appView.options(), committed).computeFinalSynthetics(appView);
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java
new file mode 100644
index 0000000..03b7e36
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMarker.java
@@ -0,0 +1,96 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.android.tools.r8.utils.Pair;
+
+public class SyntheticMarker {
+
+ public static void addMarkerToClass(
+ DexProgramClass clazz,
+ SyntheticKind kind,
+ SynthesizingContext context,
+ DexItemFactory factory) {
+ clazz.setAnnotations(
+ clazz
+ .annotations()
+ .getWithAddedOrReplaced(
+ DexAnnotation.createAnnotationSynthesizedClass(
+ kind, context.getSynthesizingContextType(), factory)));
+ }
+
+ public static SyntheticMarker stripMarkerFromClass(
+ DexProgramClass clazz, DexItemFactory factory) {
+ SyntheticMarker marker = internalStripMarkerFromClass(clazz, factory);
+ assert marker != NO_MARKER
+ || DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory)
+ == null;
+ return marker;
+ }
+
+ private static SyntheticMarker internalStripMarkerFromClass(
+ DexProgramClass clazz, DexItemFactory factory) {
+ ClassAccessFlags flags = clazz.accessFlags;
+ if (clazz.superType != factory.objectType) {
+ return NO_MARKER;
+ }
+ if (!flags.isSynthetic() || flags.isAbstract() || flags.isEnum()) {
+ return NO_MARKER;
+ }
+ Pair<SyntheticKind, DexType> info =
+ DexAnnotation.getSynthesizedClassAnnotationContextType(clazz.annotations(), factory);
+ if (info == null) {
+ return NO_MARKER;
+ }
+ assert clazz.annotations().size() == 1;
+ SyntheticKind kind = info.getFirst();
+ DexType context = info.getSecond();
+ if (kind.isSingleSyntheticMethod) {
+ if (!clazz.interfaces.isEmpty()) {
+ return NO_MARKER;
+ }
+ for (DexEncodedMethod method : clazz.methods()) {
+ if (!SyntheticMethodBuilder.isValidSyntheticMethod(method)) {
+ return NO_MARKER;
+ }
+ }
+ }
+ clazz.setAnnotations(DexAnnotationSet.empty());
+ return new SyntheticMarker(kind, SynthesizingContext.fromSyntheticInputClass(clazz, context));
+ }
+
+ private static final SyntheticMarker NO_MARKER = new SyntheticMarker(null, null);
+
+ private final SyntheticKind kind;
+ private final SynthesizingContext context;
+
+ public SyntheticMarker(SyntheticKind kind, SynthesizingContext context) {
+ this.kind = kind;
+ this.context = context;
+ }
+
+ public boolean isSyntheticMethods() {
+ return kind != null && kind.isSingleSyntheticMethod;
+ }
+
+ public boolean isSyntheticClass() {
+ return kind != null && !kind.isSingleSyntheticMethod;
+ }
+
+ public SyntheticKind getKind() {
+ return kind;
+ }
+
+ public SynthesizingContext getContext() {
+ return context;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
index 9fcc7d9..ab4cd49 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
@@ -19,16 +20,26 @@
Code generate(DexMethod method);
}
- private final SyntheticClassBuilder parent;
- private final String name;
+ private final SyntheticClassBuilder<?, ?> parent;
+ private DexString name = null;
private DexProto proto = null;
private CfVersion classFileVersion;
private SyntheticCodeGenerator codeGenerator = null;
private MethodAccessFlags accessFlags = null;
- SyntheticMethodBuilder(SyntheticClassBuilder parent, String name) {
+ SyntheticMethodBuilder(SyntheticClassBuilder<?, ?> parent) {
this.parent = parent;
+ }
+
+ public SyntheticMethodBuilder setName(String name) {
+ return setName(parent.getFactory().createString(name));
+ }
+
+ public SyntheticMethodBuilder setName(DexString name) {
+ assert name != null;
+ assert this.name == null;
this.name = name;
+ return this;
}
public SyntheticMethodBuilder setProto(DexProto proto) {
@@ -52,6 +63,7 @@
}
DexEncodedMethod build() {
+ assert name != null;
boolean isCompilerSynthesized = true;
DexMethod methodSignature = getMethodSignature();
DexEncodedMethod method =
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
index ecc1a81..87393f7 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
@@ -3,78 +3,74 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.synthesis;
-import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.structural.RepresentativeMap;
-import com.google.common.hash.HashCode;
import com.google.common.hash.Hasher;
-import com.google.common.hash.Hashing;
-import java.util.Comparator;
+import java.util.function.Consumer;
/**
* Definition of a synthetic method item.
*
* <p>This class is internal to the synthetic items collection, thus package-protected.
*/
-class SyntheticMethodDefinition extends SyntheticDefinition
- implements Comparable<SyntheticMethodDefinition> {
+class SyntheticMethodDefinition
+ extends SyntheticDefinition<
+ SyntheticMethodReference, SyntheticMethodDefinition, DexProgramClass>
+ implements SyntheticProgramDefinition {
private final ProgramMethod method;
- SyntheticMethodDefinition(SynthesizingContext context, ProgramMethod method) {
- super(context);
+ SyntheticMethodDefinition(SyntheticKind kind, SynthesizingContext context, ProgramMethod method) {
+ super(kind, context);
this.method = method;
}
+ @Override
+ public void apply(
+ Consumer<SyntheticMethodDefinition> onMethod,
+ Consumer<SyntheticProgramClassDefinition> onClass) {
+ onMethod.accept(this);
+ }
+
public ProgramMethod getMethod() {
return method;
}
@Override
- SyntheticReference toReference() {
- return new SyntheticMethodReference(getContext(), method.getReference());
+ public boolean isProgramDefinition() {
+ return true;
}
@Override
- DexProgramClass getHolder() {
+ public SyntheticProgramDefinition asProgramDefinition() {
+ return this;
+ }
+
+ @Override
+ SyntheticMethodReference toReference() {
+ return new SyntheticMethodReference(getKind(), getContext(), method.getReference());
+ }
+
+ @Override
+ public DexProgramClass getHolder() {
return method.getHolder();
}
@Override
- HashCode computeHash(RepresentativeMap map, boolean intermediate) {
- Hasher hasher = Hashing.sha256().newHasher();
- if (intermediate) {
- // If in intermediate mode, include the context type as sharing is restricted to within a
- // single context.
- hasher.putInt(getContext().getSynthesizingContextType().hashCode());
- }
- method.getDefinition().hashSyntheticContent(hasher, map);
- return hasher.hash();
+ void internalComputeHash(Hasher hasher, RepresentativeMap map) {
+ method.getDefinition().hashWithTypeEquivalence(hasher, map);
}
@Override
- boolean isEquivalentTo(SyntheticDefinition other, boolean intermediate) {
- if (!(other instanceof SyntheticMethodDefinition)) {
- return false;
- }
- if (intermediate
- && getContext().getSynthesizingContextType()
- != other.getContext().getSynthesizingContextType()) {
- // If in intermediate mode, only synthetics within the same context should be considered
- // equal.
- return false;
- }
- SyntheticMethodDefinition o = (SyntheticMethodDefinition) other;
- return method.getDefinition().isSyntheticContentEqual(o.method.getDefinition());
+ int internalCompareTo(SyntheticMethodDefinition other, RepresentativeMap map) {
+ return method.getDefinition().compareWithTypeEquivalenceTo(other.method.getDefinition(), map);
}
- // Since methods are sharable they must define an order from which representatives can be found.
@Override
- public int compareTo(SyntheticMethodDefinition other) {
- return Comparator.comparing(SyntheticMethodDefinition::getContext)
- .thenComparing(m -> m.method.getDefinition(), DexEncodedMethod::syntheticCompareTo)
- .compare(this, other);
+ public boolean isValid() {
+ return SyntheticMethodBuilder.isValidSyntheticMethod(method.getDefinition());
}
@Override
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
index 28913d0..09a0f1a 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
@@ -5,10 +5,12 @@
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import java.util.function.Consumer;
import java.util.function.Function;
/**
@@ -16,37 +18,36 @@
*
* <p>This class is internal to the synthetic items collection, thus package-protected.
*/
-class SyntheticMethodReference extends SyntheticReference {
+class SyntheticMethodReference
+ extends SyntheticReference<SyntheticMethodReference, SyntheticMethodDefinition, DexProgramClass>
+ implements SyntheticProgramReference {
final DexMethod method;
- SyntheticMethodReference(SynthesizingContext context, DexMethod method) {
- super(context);
+ SyntheticMethodReference(SyntheticKind kind, SynthesizingContext context, DexMethod method) {
+ super(kind, context);
this.method = method;
}
@Override
- DexReference getReference() {
- return method;
- }
-
- @Override
DexType getHolder() {
return method.holder;
}
@Override
- SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
+ SyntheticMethodDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
DexClass clazz = definitions.apply(method.holder);
if (clazz == null) {
return null;
}
assert clazz.isProgramClass();
ProgramMethod definition = clazz.asProgramClass().lookupProgramMethod(method);
- return definition != null ? new SyntheticMethodDefinition(getContext(), definition) : null;
+ return definition != null
+ ? new SyntheticMethodDefinition(getKind(), getContext(), definition)
+ : null;
}
@Override
- SyntheticReference rewrite(NonIdentityGraphLens lens) {
+ SyntheticMethodReference rewrite(NonIdentityGraphLens lens) {
DexMethod rewritten = lens.lookupMethod(method);
// If the reference has been non-trivially rewritten the compiler has changed it and it can no
// longer be considered a synthetic. The context may or may not have changed.
@@ -54,12 +55,29 @@
// If the referenced item is rewritten, it should be moved to another holder as the
// synthetic holder is no longer part of the synthetic collection.
assert method.holder != rewritten.holder;
- assert SyntheticItems.verifyNotInternalSynthetic(rewritten.holder);
+ assert SyntheticNaming.verifyNotInternalSynthetic(rewritten.holder);
return null;
}
SynthesizingContext context = getContext().rewrite(lens);
- return context == getContext() && rewritten == method
- ? this
- : new SyntheticMethodReference(context, rewritten);
+ if (context == getContext() && rewritten == method) {
+ return this;
+ }
+ // Ensure that if a synthetic moves its context moves consistently.
+ if (method != rewritten) {
+ context =
+ SynthesizingContext.fromSyntheticContextChange(
+ rewritten.holder, context, lens.dexItemFactory());
+ if (context == null) {
+ return null;
+ }
+ }
+ return new SyntheticMethodReference(getKind(), context, rewritten);
+ }
+
+ @Override
+ public void apply(
+ Consumer<SyntheticMethodReference> onMethod,
+ Consumer<SyntheticProgramClassReference> onClass) {
+ onMethod.accept(this);
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
new file mode 100644
index 0000000..b33e260
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -0,0 +1,170 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.DescriptorUtils;
+
+public class SyntheticNaming {
+
+ /**
+ * Enumeration of all kinds of synthetic items.
+ *
+ * <p>The synthetic kinds are used to provide hinting about what a synthetic item represents. The
+ * kinds must *not* be used be the compiler and are only meant for "debugging". The compiler and
+ * its test may use the kind information as part of asserting properties of the compiler. The kind
+ * will be put into any non-minified synthetic name and thus the kind "descriptor" must be a
+ * distinct for each kind.
+ */
+ public enum SyntheticKind {
+ // Class synthetics.
+ COMPANION_CLASS("CompanionClass", false),
+ LAMBDA("Lambda", false),
+ // Method synthetics.
+ BACKPORT("Backport", true),
+ STATIC_INTERFACE_CALL("StaticInterfaceCall", true),
+ TO_STRING_IF_NOT_NULL("ToStringIfNotNull", true),
+ THROW_CCE_IF_NOT_NULL("ThrowCCEIfNotNull", true),
+ THROW_ICCE("ThrowICCE", true),
+ THROW_NSME("ThrowNSME", true),
+ TWR_CLOSE_RESOURCE("TwrCloseResource", true),
+ SERVICE_LOADER("ServiceLoad", true);
+
+ public final String descriptor;
+ public final boolean isSingleSyntheticMethod;
+
+ SyntheticKind(String descriptor, boolean isSingleSyntheticMethod) {
+ this.descriptor = descriptor;
+ this.isSingleSyntheticMethod = isSingleSyntheticMethod;
+ }
+
+ public static SyntheticKind fromDescriptor(String descriptor) {
+ for (SyntheticKind kind : values()) {
+ if (kind.descriptor.equals(descriptor)) {
+ return kind;
+ }
+ }
+ return null;
+ }
+ }
+
+ /**
+ * The internal synthetic class separator is only used for representing synthetic items during
+ * compilation. In particular, this separator must never be used to write synthetic classes to the
+ * final compilation result.
+ */
+ private static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$InternalSynthetic";
+ /**
+ * The external synthetic class separator is used when writing classes. It may appear in types
+ * during compilation as the output of a compilation may be the input to another.
+ */
+ private static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$ExternalSynthetic";
+ /** Method prefix when generating synthetic methods in a class. */
+ static final String INTERNAL_SYNTHETIC_METHOD_PREFIX = "m";
+
+ // TODO(b/158159959): Remove usage of name-based identification.
+ public static boolean isSyntheticName(String typeName) {
+ return typeName.contains(INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
+ || typeName.contains(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR);
+ }
+
+ static DexType createInternalType(
+ SyntheticKind kind, SynthesizingContext context, String id, DexItemFactory factory) {
+ return createType(
+ INTERNAL_SYNTHETIC_CLASS_SEPARATOR,
+ kind,
+ context.getSynthesizingContextType(),
+ id,
+ factory);
+ }
+
+ static DexType createExternalType(
+ SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
+ return createType(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR, kind, context, id, factory);
+ }
+
+ private static DexType createType(
+ String separator, SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
+ return factory.createType(createDescriptor(separator, kind, context.getInternalName(), id));
+ }
+
+ private static String createDescriptor(
+ String separator, SyntheticKind kind, String context, String id) {
+ return DescriptorUtils.getDescriptorFromClassBinaryName(
+ context + separator + kind.descriptor + id);
+ }
+
+ public static boolean verifyNotInternalSynthetic(DexType type) {
+ return verifyNotInternalSynthetic(type.toDescriptorString());
+ }
+
+ public static boolean verifyNotInternalSynthetic(ClassReference reference) {
+ return verifyNotInternalSynthetic(reference.getDescriptor());
+ }
+
+ public static boolean verifyNotInternalSynthetic(String typeBinaryNameOrDescriptor) {
+ assert !typeBinaryNameOrDescriptor.contains(INTERNAL_SYNTHETIC_CLASS_SEPARATOR);
+ return true;
+ }
+
+ // Visible via package protection in SyntheticItemsTestUtils.
+
+ enum Phase {
+ INTERNAL,
+ EXTERNAL
+ }
+
+ static String getPhaseSeparator(Phase phase) {
+ assert phase != null;
+ return phase == Phase.INTERNAL
+ ? INTERNAL_SYNTHETIC_CLASS_SEPARATOR
+ : EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
+ }
+
+ static ClassReference makeSyntheticReferenceForTest(
+ ClassReference context, SyntheticKind kind, String id) {
+ return Reference.classFromDescriptor(
+ createDescriptor(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR, kind, context.getBinaryName(), id));
+ }
+
+ static boolean isSynthetic(ClassReference clazz, Phase phase, SyntheticKind kind) {
+ String typeName = clazz.getTypeName();
+ String separator = getPhaseSeparator(phase);
+ int i = typeName.indexOf(separator);
+ return i >= 0 && checkMatchFrom(kind, typeName, i, separator, phase == Phase.EXTERNAL);
+ }
+
+ private static boolean checkMatchFrom(
+ SyntheticKind kind,
+ String name,
+ int i,
+ String externalSyntheticClassSeparator,
+ boolean checkIntSuffix) {
+ int end = i + externalSyntheticClassSeparator.length() + kind.descriptor.length();
+ if (end >= name.length()) {
+ return false;
+ }
+ String prefix = name.substring(i, end);
+ return prefix.equals(externalSyntheticClassSeparator + kind.descriptor)
+ && (!checkIntSuffix || isInt(name.substring(end)));
+ }
+
+ private static boolean isInt(String str) {
+ if (str.isEmpty()) {
+ return false;
+ }
+ if ('0' == str.charAt(0)) {
+ return str.length() == 1;
+ }
+ for (int i = 0; i < str.length(); i++) {
+ if (!Character.isDigit(str.charAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassBuilder.java
new file mode 100644
index 0000000..6408621
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassBuilder.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+
+public class SyntheticProgramClassBuilder
+ extends SyntheticClassBuilder<SyntheticProgramClassBuilder, DexProgramClass> {
+
+ SyntheticProgramClassBuilder(DexType type, SynthesizingContext context, DexItemFactory factory) {
+ super(type, context, factory);
+ }
+
+ @Override
+ public ClassKind<DexProgramClass> getClassKind() {
+ return ClassKind.PROGRAM;
+ }
+
+ @Override
+ public SyntheticProgramClassBuilder self() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java
new file mode 100644
index 0000000..8b42eb6
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java
@@ -0,0 +1,74 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.android.tools.r8.utils.structural.RepresentativeMap;
+import com.google.common.hash.Hasher;
+import java.util.function.Consumer;
+
+/**
+ * Definition of a synthetic class item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SyntheticProgramClassDefinition
+ extends SyntheticClassDefinition<
+ SyntheticProgramClassReference, SyntheticProgramClassDefinition, DexProgramClass>
+ implements SyntheticProgramDefinition {
+
+ SyntheticProgramClassDefinition(
+ SyntheticKind kind, SynthesizingContext context, DexProgramClass clazz) {
+ super(kind, context, clazz);
+ }
+
+ @Override
+ public void apply(
+ Consumer<SyntheticMethodDefinition> onMethod,
+ Consumer<SyntheticProgramClassDefinition> onClass) {
+ onClass.accept(this);
+ }
+
+ @Override
+ public boolean isProgramDefinition() {
+ return true;
+ }
+
+ @Override
+ public SyntheticProgramDefinition asProgramDefinition() {
+ return this;
+ }
+
+ @Override
+ SyntheticProgramClassReference toReference() {
+ return new SyntheticProgramClassReference(getKind(), getContext(), clazz.getType());
+ }
+
+ @Override
+ public boolean isValid() {
+ return clazz.isPublic() && clazz.isFinal() && clazz.accessFlags.isSynthetic();
+ }
+
+ @Override
+ void internalComputeHash(Hasher hasher, RepresentativeMap map) {
+ clazz.hashWithTypeEquivalence(hasher, map);
+ }
+
+ @Override
+ int internalCompareTo(SyntheticProgramClassDefinition o, RepresentativeMap map) {
+ return clazz.compareWithTypeEquivalenceTo(o.clazz, map);
+ }
+
+ @Override
+ public String toString() {
+ return "SyntheticProgramClass{ clazz = "
+ + clazz.type.toSourceString()
+ + ", kind = "
+ + getKind()
+ + ", context = "
+ + getContext()
+ + " }";
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
new file mode 100644
index 0000000..3472268
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
@@ -0,0 +1,70 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Reference to a synthetic class item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SyntheticProgramClassReference
+ extends SyntheticClassReference<
+ SyntheticProgramClassReference, SyntheticProgramClassDefinition, DexProgramClass>
+ implements SyntheticProgramReference {
+
+ SyntheticProgramClassReference(SyntheticKind kind, SynthesizingContext context, DexType type) {
+ super(kind, context, type);
+ }
+
+ @Override
+ SyntheticProgramClassDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
+ DexClass clazz = definitions.apply(type);
+ if (clazz == null) {
+ return null;
+ }
+ assert clazz.isProgramClass();
+ return new SyntheticProgramClassDefinition(getKind(), getContext(), clazz.asProgramClass());
+ }
+
+ @Override
+ SyntheticProgramClassReference rewrite(NonIdentityGraphLens lens) {
+ DexType rewritten = lens.lookupType(type);
+ // If the reference has been non-trivially rewritten the compiler has changed it and it can no
+ // longer be considered a synthetic. The context may or may not have changed.
+ if (type != rewritten && !lens.isSimpleRenaming(type, rewritten)) {
+ // If the referenced item is rewritten, it should be moved to another holder as the
+ // synthetic holder is no longer part of the synthetic collection.
+ assert SyntheticNaming.verifyNotInternalSynthetic(rewritten);
+ return null;
+ }
+ SynthesizingContext context = getContext().rewrite(lens);
+ if (context == getContext() && rewritten == type) {
+ return this;
+ }
+ // Ensure that if a synthetic moves its context moves consistently.
+ if (type != rewritten) {
+ context =
+ SynthesizingContext.fromSyntheticContextChange(rewritten, context, lens.dexItemFactory());
+ if (context == null) {
+ return null;
+ }
+ }
+ return new SyntheticProgramClassReference(getKind(), context, rewritten);
+ }
+
+ @Override
+ public void apply(
+ Consumer<SyntheticMethodReference> onMethod,
+ Consumer<SyntheticProgramClassReference> onClass) {
+ onClass.accept(this);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramDefinition.java
new file mode 100644
index 0000000..dd8953a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramDefinition.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.synthesis;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import java.util.function.Consumer;
+
+public interface SyntheticProgramDefinition {
+
+ void apply(
+ Consumer<SyntheticMethodDefinition> onMethod,
+ Consumer<SyntheticProgramClassDefinition> onClass);
+
+ DexProgramClass getHolder();
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramReference.java
new file mode 100644
index 0000000..4df1f46
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramReference.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.synthesis;
+
+import java.util.function.Consumer;
+
+public interface SyntheticProgramReference {
+
+ void apply(
+ Consumer<SyntheticMethodReference> onMethod,
+ Consumer<SyntheticProgramClassReference> onClass);
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
index 6618378..1a2d2fb 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.synthesis;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import java.util.function.Function;
/**
@@ -14,16 +14,26 @@
*
* <p>This class is internal to the synthetic items collection, thus package-protected.
*/
-abstract class SyntheticReference {
+abstract class SyntheticReference<
+ R extends SyntheticReference<R, D, C>,
+ D extends SyntheticDefinition<R, D, C>,
+ C extends DexClass> {
+
+ private final SyntheticKind kind;
private final SynthesizingContext context;
- SyntheticReference(SynthesizingContext context) {
+ SyntheticReference(SyntheticKind kind, SynthesizingContext context) {
+ assert kind != null;
+ assert context != null;
+ this.kind = kind;
this.context = context;
}
- abstract SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions);
+ abstract D lookupDefinition(Function<DexType, DexClass> definitions);
- abstract DexReference getReference();
+ final SyntheticKind getKind() {
+ return kind;
+ }
final SynthesizingContext getContext() {
return context;
@@ -31,5 +41,5 @@
abstract DexType getHolder();
- abstract SyntheticReference rewrite(NonIdentityGraphLens lens);
+ abstract R rewrite(NonIdentityGraphLens lens);
}
diff --git a/src/main/java/com/android/tools/r8/utils/BooleanBox.java b/src/main/java/com/android/tools/r8/utils/BooleanBox.java
index f46ac1c..f6b790d 100644
--- a/src/main/java/com/android/tools/r8/utils/BooleanBox.java
+++ b/src/main/java/com/android/tools/r8/utils/BooleanBox.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.utils;
+import java.util.function.BooleanSupplier;
+
public class BooleanBox {
private boolean value;
@@ -14,10 +16,24 @@
set(initialValue);
}
+ public void computeIfNotSet(BooleanSupplier supplier) {
+ if (isFalse()) {
+ set(supplier.getAsBoolean());
+ }
+ }
+
public boolean get() {
return value;
}
+ public boolean isFalse() {
+ return !get();
+ }
+
+ public boolean isTrue() {
+ return get();
+ }
+
public void set() {
set(true);
}
diff --git a/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java b/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java
index 28eb17b..e14d8ed 100644
--- a/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java
+++ b/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java
@@ -10,10 +10,19 @@
/** Represents a collection of classpath classes. */
public class ClasspathClassCollection extends ClassMap<DexClasspathClass> {
+
+ private ClasspathClassCollection() {
+ this(null);
+ }
+
public ClasspathClassCollection(ClassProvider<DexClasspathClass> classProvider) {
super(null, classProvider);
}
+ public static ClasspathClassCollection empty() {
+ return new ClasspathClassCollection();
+ }
+
@Override
DexClasspathClass resolveClassConflict(DexClasspathClass a, DexClasspathClass b) {
throw new CompilationError("Classpath type already present: " + a.type.toSourceString());
diff --git a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
index 8c4da03..ef5c3ca 100644
--- a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
@@ -22,9 +22,20 @@
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
public abstract class ExceptionUtils {
+ public static String getMainStackTrace() {
+ return Thread.getAllStackTraces().entrySet().stream()
+ .filter(x -> x.getKey().getName().equals("main"))
+ .map(x -> x.getValue())
+ .flatMap(x -> Stream.of(x))
+ .map(x -> x.toString())
+ .collect(Collectors.joining(System.lineSeparator()));
+ }
+
public static void withConsumeResourceHandler(
Reporter reporter, StringConsumer consumer, String data) {
withConsumeResourceHandler(reporter, handler -> consumer.accept(data, handler));
diff --git a/src/main/java/com/android/tools/r8/utils/FilteredArchiveClassFileProvider.java b/src/main/java/com/android/tools/r8/utils/FilteredArchiveClassFileProvider.java
index 43cbb4d..483315e 100644
--- a/src/main/java/com/android/tools/r8/utils/FilteredArchiveClassFileProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/FilteredArchiveClassFileProvider.java
@@ -10,6 +10,6 @@
class FilteredArchiveClassFileProvider extends InternalArchiveClassFileProvider {
FilteredArchiveClassFileProvider(FilteredClassPath archive) throws IOException {
- super(archive.getPath(), entry -> archive.matchesFile(entry));
+ super(archive.getPath(), archive::matchesFile);
}
}
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 db914a4..a8bec4a 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.utils;
-import static com.google.common.base.Predicates.not;
import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.CompilationMode;
@@ -32,10 +31,11 @@
import com.android.tools.r8.features.FeatureSplitConfiguration;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexDefinition;
+import com.android.tools.r8.graph.DexClasspathClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItem;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexLibraryClass;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
@@ -48,6 +48,7 @@
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.conversion.MethodProcessingId;
import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
+import com.android.tools.r8.ir.desugar.nest.Nest;
import com.android.tools.r8.ir.optimize.Inliner;
import com.android.tools.r8.ir.optimize.enums.EnumDataMap;
import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
@@ -73,13 +74,7 @@
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
-import java.io.IOException;
import java.io.PrintStream;
-import java.lang.reflect.GenericSignatureFormatError;
-import java.nio.file.Files;
-import java.nio.file.InvalidPathException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@@ -307,6 +302,7 @@
// the actual catch handler allowed when inlining. Threshold found empirically by testing on
// GMS Core.
public int inliningControlFlowResolutionBlocksThreshold = 15;
+ public boolean enableSwitchRewriting = true;
public boolean enableStringSwitchConversion = true;
public int minimumStringSwitchSize = 3;
public boolean enableEnumValueOptimization = true;
@@ -492,7 +488,7 @@
if (testing.enableForceNestBasedAccessDesugaringForTest) {
return true;
}
- return enableNestBasedAccessDesugaring && !canUseNestBasedAccess();
+ return !canUseNestBasedAccess();
}
public Set<String> extensiveLoggingFilter = getExtensiveLoggingFilter();
@@ -513,10 +509,6 @@
public boolean enableLambdaMerging = false;
// Flag to turn on/off desugaring in D8/R8.
public DesugarState desugarState = DesugarState.ON;
- // Flag to turn on/off desugaring of invoke-special to a virtual method on the current class.
- public boolean enableInvokeSpecialToVirtualMethodDesugaring = true;
- // Flag to turn on/off JDK11+ nest-access control
- public boolean enableNestBasedAccessDesugaring = true;
// Flag to turn on/off reduction of nest to improve class merging optimizations.
public boolean enableNestReduction = true;
// Defines interface method rewriter behavior.
@@ -611,6 +603,7 @@
public boolean printCfg = false;
public String printCfgFile;
public boolean ignoreMissingClasses = false;
+
// EXPERIMENTAL flag to get behaviour as close to Proguard as possible.
public boolean forceProguardCompatibility = false;
public AssertionConfigurationWithDefault assertionsConfiguration = null;
@@ -680,19 +673,6 @@
return ImmutableSet.of();
}
- private static Set<String> getExtensiveFieldMinifierLoggingFilter() {
- String property =
- System.getProperty("com.android.tools.r8.extensiveFieldMinifierLoggingFilter");
- if (property != null) {
- ImmutableSet.Builder<String> builder = ImmutableSet.builder();
- for (String method : property.split(";")) {
- builder.add(method);
- }
- return builder.build();
- }
- return ImmutableSet.of();
- }
-
private static Set<String> getExtensiveInterfaceMethodMinifierLoggingFilter() {
String property =
System.getProperty("com.android.tools.r8.extensiveInterfaceMethodMinifierLoggingFilter");
@@ -706,40 +686,6 @@
return ImmutableSet.of();
}
- private static Set<String> getNullableReceiverInliningFilter() {
- String property = System.getProperty("com.android.tools.r8.nullableReceiverInliningFilter");
- if (property != null) {
- // The property is allowed to be either (1) a path to a file where each line is a method
- // signature, or (2) a semicolon separated list of method signatures.
- Path path = null;
- try {
- Path tmp = Paths.get(property);
- if (Files.exists(tmp)) {
- path = tmp;
- }
- } catch (InvalidPathException | NullPointerException e) {
- // Ignore, treat as a semicolon separated list of method signatures.
- }
- ImmutableSet.Builder<String> builder = ImmutableSet.builder();
- if (path != null) {
- try {
- Files.readAllLines(path).stream()
- .map(String::trim)
- .filter(not(String::isEmpty))
- .forEach(builder::add);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- } else {
- for (String method : property.split(";")) {
- builder.add(method);
- }
- }
- return builder.build();
- }
- return ImmutableSet.of();
- }
-
public static class InvalidParameterAnnotationInfo {
final DexMethod method;
@@ -845,121 +791,64 @@
private final Set<DexItem> invalidLibraryClasses = Sets.newConcurrentHashSet();
- public void errorMissingClassMissingNestHost(DexClass compiledClass) {
- throw reporter.fatalError(messageErrorMissingNestHost(compiledClass));
- }
-
- public void warningMissingClassMissingNestHost(DexClass compiledClass) {
- if (compiledClass.isLibraryClass()) {
- errorMissingClassMissingNestHost(compiledClass);
- }
- reporter.warning(new StringDiagnostic(messageWarningMissingNestHost(compiledClass)));
- }
-
- public void nestDesugaringWarningMissingNestHost(DexClass compiledClass) {
- if (compiledClass.isLibraryClass()) {
- errorMissingClassMissingNestHost(compiledClass);
- }
- reporter.warning(
+ public RuntimeException errorMissingNestHost(DexClass clazz) {
+ throw reporter.fatalError(
new MissingNestHostNestDesugarDiagnostic(
- compiledClass.getOrigin(),
- Position.UNKNOWN,
- messageWarningMissingNestHost(compiledClass)));
+ clazz.getOrigin(), Position.UNKNOWN, messageErrorMissingNestHost(clazz)));
}
- public void errorMissingClassIncompleteNest(List<DexType> nest, AppView<?> appView) {
- throw reporter.fatalError(messageErrorIncompleteNest(nest, appView));
- }
-
- public void warningMissingClassIncompleteNest(List<DexType> nest, AppView<?> appView) {
- for (DexType type : nest) {
- DexClass clazz = appView.definitionFor(type);
- if (clazz != null && clazz.isLibraryClass()) {
- errorMissingClassIncompleteNest(nest, appView);
- return;
- }
- }
- reporter.warning(new StringDiagnostic(messageWarningIncompleteNest(nest, appView)));
- }
-
- public void nestDesugaringWarningIncompleteNest(List<DexType> nest, AppView<?> appView) {
- DexClass availableClass = null;
- for (DexType type : nest) {
- DexClass clazz = appView.definitionFor(type);
- if (clazz != null && clazz.isProgramClass()) {
- availableClass = clazz;
- } else if (clazz != null && clazz.isLibraryClass()) {
- errorMissingClassIncompleteNest(nest, appView);
- return;
- }
- }
- assert availableClass != null;
- reporter.warning(
- new IncompleteNestNestDesugarDiagnosic(
- availableClass.getOrigin(),
- Position.UNKNOWN,
- messageWarningIncompleteNest(nest, appView)));
- }
-
- private String messageErrorMissingNestHost(DexClass compiledClass) {
+ private static String messageErrorMissingNestHost(DexClass compiledClass) {
String nestHostName = compiledClass.getNestHost().getName();
return "Class "
+ compiledClass.type.getName()
+ " requires its nest host "
+ nestHostName
- + " to be on program or class path. ";
+ + " to be on program or class path.";
}
- private String messageWarningMissingNestHost(DexClass compiledClass) {
- return messageErrorMissingNestHost(compiledClass)
- + "Class "
- + compiledClass.type.getName()
- + " is considered as not being part of any nest.";
+ public RuntimeException errorMissingNestMember(Nest nest) {
+ throw reporter.fatalError(
+ new IncompleteNestNestDesugarDiagnosic(
+ nest.getHostClass().getOrigin(), Position.UNKNOWN, messageErrorIncompleteNest(nest)));
}
- private String messageErrorIncompleteNest(List<DexType> nest, AppView<?> appView) {
- List<String> programClassesFromNest = new ArrayList<>();
- List<String> unavailableClasses = new ArrayList<>();
- List<String> classPathClasses = new ArrayList<>();
- List<String> libraryClasses = new ArrayList<>();
- for (DexType type : nest) {
- DexClass clazz = appView.definitionFor(appView.graphLens().lookupType(type));
- if (clazz == null) {
- unavailableClasses.add(type.getName());
- } else if (clazz.isLibraryClass()) {
- libraryClasses.add(type.getName());
- } else if (clazz.isProgramClass()) {
- programClassesFromNest.add(type.getName());
- } else {
- assert clazz.isClasspathClass();
- classPathClasses.add(type.getName());
- }
+ private static String messageErrorIncompleteNest(Nest nest) {
+ List<DexProgramClass> programClassesFromNest = new ArrayList<>();
+ List<DexClasspathClass> classpathClassesFromNest = new ArrayList<>();
+ List<DexLibraryClass> libraryClassesFromNest = new ArrayList<>();
+ nest.getHostClass()
+ .accept(
+ programClassesFromNest::add,
+ classpathClassesFromNest::add,
+ libraryClassesFromNest::add);
+ for (DexClass memberClass : nest.getMembers()) {
+ memberClass.accept(
+ programClassesFromNest::add, classpathClassesFromNest::add, libraryClassesFromNest::add);
}
StringBuilder stringBuilder =
new StringBuilder("Compilation of classes ")
- .append(String.join(", ", programClassesFromNest))
+ .append(StringUtils.join(", ", programClassesFromNest, DexClass::getTypeName))
.append(" requires its nest mates ");
- if (!unavailableClasses.isEmpty()) {
- stringBuilder.append(String.join(", ", unavailableClasses)).append(" (unavailable) ");
+ if (nest.hasMissingMembers()) {
+ stringBuilder
+ .append(StringUtils.join(", ", nest.getMissingMembers(), DexType::getTypeName))
+ .append(" (unavailable) ");
}
- if (!libraryClasses.isEmpty()) {
- stringBuilder.append(String.join(", ", unavailableClasses)).append(" (on library path) ");
+ if (!libraryClassesFromNest.isEmpty()) {
+ stringBuilder
+ .append(StringUtils.join(", ", libraryClassesFromNest, DexClass::getTypeName))
+ .append(" (on library path) ");
}
stringBuilder.append("to be on program or class path.");
- if (!classPathClasses.isEmpty()) {
+ if (!classpathClassesFromNest.isEmpty()) {
stringBuilder
.append("(Classes ")
- .append(String.join(", ", classPathClasses))
+ .append(StringUtils.join(", ", classpathClassesFromNest, DexClass::getTypeName))
.append(" from the same nest are on class path).");
}
return stringBuilder.toString();
}
- private String messageWarningIncompleteNest(List<DexType> nest, AppView<?> appView) {
- return messageErrorIncompleteNest(nest, appView)
- + " Unavailable classes are considered as not being part of the nest.";
- }
-
public void warningMissingTypeForDesugar(
Origin origin, Position position, DexType missingType, DexMethod context) {
if (reportedMissingForDesugaring.add(missingType)) {
@@ -1034,31 +923,6 @@
}
}
- public void warningInvalidSignature(
- DexDefinition item, Origin origin, String signature, GenericSignatureFormatError e) {
- StringBuilder message = new StringBuilder("Invalid signature '");
- message.append(signature);
- message.append("' for ");
- if (item.isDexClass()) {
- message.append("class ");
- message.append((item.asDexClass()).getType().toSourceString());
- } else if (item.isDexEncodedField()) {
- message.append("field ");
- message.append(item.toSourceString());
- } else {
- assert item.isDexEncodedMethod();
- message.append("method ");
- message.append(item.toSourceString());
- }
- message.append(".");
- message.append(System.lineSeparator());
- message.append("Signature is ignored and will not be present in the output.");
- message.append(System.lineSeparator());
- message.append("Parser error: ");
- message.append(e.getMessage());
- reporter.warning(new StringDiagnostic(message.toString(), origin));
- }
-
private final Box<Boolean> reportedExperimentClassFileVersion = new Box<>(false);
public void warningExperimentalClassFileVersion(Origin origin) {
@@ -1280,6 +1144,7 @@
public boolean enable = true;
public boolean enableConstructorMerging = true;
+ // TODO(b/174809311): Update or remove the option and its tests after new lambdas synthetics.
public boolean enableJavaLambdaMerging = false;
public boolean enableKotlinLambdaMerging = true;
@@ -1429,14 +1294,15 @@
public boolean addCallEdgesForLibraryInvokes = false;
public boolean allowCheckDiscardedErrors = false;
+ public boolean allowDexInputForTesting = false;
public boolean allowInjectedAnnotationMethods = false;
public boolean allowTypeErrors =
!Version.isDevelopmentVersion()
|| System.getProperty("com.android.tools.r8.allowTypeErrors") != null;
public boolean allowInvokeErrors = false;
+ public boolean allowUnnecessaryDontWarnWildcards = true;
+ public boolean allowUnusedDontWarnRules = true;
public boolean disableL8AnnotationRemoval = false;
- public boolean allowClassInlinerGracefulExit =
- System.getProperty("com.android.tools.r8.disallowClassInlinerGracefulExit") == null;
public boolean reportUnusedProguardConfigurationRules = false;
public boolean alwaysUseExistingAccessInfoCollectionsInMemberRebinding = true;
public boolean alwaysUsePessimisticRegisterAllocation = false;
@@ -1458,7 +1324,6 @@
public Consumer<IRCode> irModifier = null;
public int basicBlockMuncherIterationLimit = NO_LIMIT;
public boolean dontReportFailingCheckDiscarded = false;
- public boolean deterministicSortingBasedOnDexType = true;
public PrintStream whyAreYouNotInliningConsumer = System.out;
public boolean trackDesugaredAPIConversions =
System.getProperty("com.android.tools.r8.trackDesugaredAPIConversions") != null;
@@ -1472,6 +1337,10 @@
public boolean disableMappingToOriginalProgramVerification = false;
public boolean allowInvalidCfAccessFlags =
System.getProperty("com.android.tools.r8.allowInvalidCfAccessFlags") != null;
+ // TODO(b/177333791): Set to true
+ public boolean checkForNotExpandingMainDexTracingResult = false;
+
+ public boolean allowConflictingSyntheticTypes = false;
// Flag to allow processing of resources in D8. A data resource consumer still needs to be
// specified.
@@ -1603,6 +1472,16 @@
return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
}
+ public boolean enableTryWithResourcesDesugaring() {
+ switch (tryWithResourcesDesugaring) {
+ case Off:
+ return false;
+ case Auto:
+ return !canUseSuppressedExceptions();
+ }
+ throw new Unreachable();
+ }
+
public boolean canUsePrivateInterfaceMethods() {
return !isDesugaring() || hasMinApi(AndroidApiLevel.N);
}
@@ -1622,6 +1501,10 @@
&& !canUseDefaultAndStaticInterfaceMethods();
}
+ public boolean isSwitchRewritingEnabled() {
+ return enableSwitchRewriting && !debug;
+ }
+
public boolean isStringSwitchConversionEnabled() {
return enableStringSwitchConversion && !debug;
}
@@ -2009,4 +1892,11 @@
public boolean canHaveDalvikIntUsedAsNonIntPrimitiveTypeBug() {
return isGeneratingClassFiles() || minApiLevel < AndroidApiLevel.L.getLevel();
}
+
+ // The standard library prior to API 19 did not contain a ZipFile that implemented Closable.
+ //
+ // See b/177532008.
+ public boolean canHaveZipFileWithMissingCloseableBug() {
+ return isGeneratingClassFiles() || minApiLevel < AndroidApiLevel.K.getLevel();
+ }
}
diff --git a/src/main/java/com/android/tools/r8/utils/IterableUtils.java b/src/main/java/com/android/tools/r8/utils/IterableUtils.java
index cd1c0a0..2b0267d 100644
--- a/src/main/java/com/android/tools/r8/utils/IterableUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/IterableUtils.java
@@ -59,10 +59,14 @@
return -1;
}
- public static <T> Iterable<T> filter(Iterable<T> iterable, Predicate<T> predicate) {
+ public static <T> Iterable<T> filter(Iterable<T> iterable, Predicate<? super T> predicate) {
return () -> IteratorUtils.filter(iterable.iterator(), predicate);
}
+ public static <T> boolean hasNext(Iterable<T> iterable) {
+ return iterable.iterator().hasNext();
+ }
+
public static <T> int size(Iterable<T> iterable) {
int result = 0;
for (T element : iterable) {
@@ -77,6 +81,10 @@
return result;
}
+ public static <S, T> Iterable<T> transform(Iterable<S> iterable, Function<S, T> fn) {
+ return Iterables.transform(iterable, fn::apply);
+ }
+
public static <T> boolean isEmpty(Iterable<T> iterable) {
return !iterable.iterator().hasNext();
}
@@ -102,13 +110,13 @@
}
public static <F> int sumInt(Iterable<F> iterable, Function<? super F, Integer> fn) {
- Iterable<Integer> integers = Iterables.transform(iterable, i -> fn.apply(i));
+ Iterable<Integer> integers = Iterables.transform(iterable, fn::apply);
return sumInt(integers);
}
public static <T, U> Iterable<U> flatMap(
Iterable<T> iterable, Function<? super T, Iterable<U>> map) {
- return Iterables.concat(Iterables.transform(iterable, val -> map.apply(val)));
+ return Iterables.concat(Iterables.transform(iterable, map::apply));
}
public static <T> Iterable<T> empty() {
diff --git a/src/main/java/com/android/tools/r8/utils/ListUtils.java b/src/main/java/com/android/tools/r8/utils/ListUtils.java
index 40ae9ce..e6b0085 100644
--- a/src/main/java/com/android/tools/r8/utils/ListUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ListUtils.java
@@ -14,6 +14,36 @@
public class ListUtils {
+ /**
+ * Maps each element in the list using on the given function. Returns the mapped list if any
+ * elements were rewritten, otherwise returns the original list.
+ *
+ * <p>If the given function {@param fn} returns null for an element {@code v}, this is interpreted
+ * as the singleton list containing {@code v} (i.e., no changes should be made to the given
+ * element).
+ */
+ public static <T> List<T> flatMap(List<T> list, Function<T, List<T>> fn, List<T> defaultValue) {
+ List<T> result = null;
+ for (int i = 0; i < list.size(); i++) {
+ T element = list.get(i);
+ List<T> replacement = fn.apply(element);
+ if (replacement == null) {
+ if (result != null) {
+ result.add(element);
+ }
+ } else {
+ if (result == null) {
+ result = new ArrayList<>(list.size() + replacement.size() - 1);
+ for (int j = 0; j < i; j++) {
+ result.add(list.get(j));
+ }
+ }
+ result.addAll(replacement);
+ }
+ }
+ return result != null ? result : defaultValue;
+ }
+
public static <T> T first(List<T> list) {
return list.get(0);
}
@@ -40,6 +70,14 @@
return -1;
}
+ public static <S, T> List<T> map(Iterable<S> list, Function<S, T> fn) {
+ List<T> result = new ArrayList<>();
+ for (S element : list) {
+ result.add(fn.apply(element));
+ }
+ return result;
+ }
+
public static <S, T> List<T> map(Collection<S> list, Function<S, T> fn) {
List<T> result = new ArrayList<>(list.size());
for (S element : list) {
diff --git a/src/main/java/com/android/tools/r8/utils/MapUtils.java b/src/main/java/com/android/tools/r8/utils/MapUtils.java
index ac79586..abae424 100644
--- a/src/main/java/com/android/tools/r8/utils/MapUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/MapUtils.java
@@ -45,6 +45,6 @@
public static String toString(Map<?, ?> map) {
return StringUtils.join(
- map.entrySet(), ",", BraceType.TUBORG, entry -> entry.getKey() + ":" + entry.getValue());
+ ",", map.entrySet(), entry -> entry.getKey() + ":" + entry.getValue(), BraceType.TUBORG);
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/Pair.java b/src/main/java/com/android/tools/r8/utils/Pair.java
index ac58f56..c2f3489 100644
--- a/src/main/java/com/android/tools/r8/utils/Pair.java
+++ b/src/main/java/com/android/tools/r8/utils/Pair.java
@@ -50,4 +50,9 @@
public boolean equals(Object obj) {
throw new Unreachable("Pair does not want to support equality!");
}
+
+ @Override
+ public String toString() {
+ return "Pair{" + first + ", " + second + '}';
+ }
}
diff --git a/src/main/java/com/android/tools/r8/utils/StringUtils.java b/src/main/java/com/android/tools/r8/utils/StringUtils.java
index a90d2bc..8f398ac 100644
--- a/src/main/java/com/android/tools/r8/utils/StringUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/StringUtils.java
@@ -108,8 +108,8 @@
return append(builder, collection, ", ", BraceType.PARENS);
}
- public static <T> StringBuilder append(StringBuilder builder, Collection<T> collection,
- String seperator, BraceType brace) {
+ public static <T> StringBuilder append(
+ StringBuilder builder, Iterable<T> collection, String seperator, BraceType brace) {
builder.append(brace.left());
boolean first = true;
for (T element : collection) {
@@ -128,18 +128,22 @@
return join(collection, separator, BraceType.NONE);
}
+ public static <T> String join(String separator, Iterable<T> iterable, Function<T, String> fn) {
+ return join(separator, iterable, fn, BraceType.NONE);
+ }
+
public static String join(String separator, String... strings) {
return join(Arrays.asList(strings), separator, BraceType.NONE);
}
public static <T> String join(Collection<T> collection, String separator, BraceType brace) {
- return join(collection, separator, brace, Object::toString);
+ return join(separator, collection, Object::toString, brace);
}
- public static <T> String join(Collection<T> collection, String separator, BraceType brace,
- Function<T, String> fn) {
+ public static <T> String join(
+ String separator, Iterable<T> iterable, Function<T, String> fn, BraceType brace) {
StringBuilder builder = new StringBuilder();
- append(builder, ListUtils.map(collection, fn), separator, brace);
+ append(builder, IterableUtils.transform(iterable, fn), separator, brace);
return builder.toString();
}
diff --git a/src/main/java/com/android/tools/r8/utils/ThreadUtils.java b/src/main/java/com/android/tools/r8/utils/ThreadUtils.java
index 2a16dbf..a8fa794 100644
--- a/src/main/java/com/android/tools/r8/utils/ThreadUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ThreadUtils.java
@@ -8,6 +8,7 @@
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -18,6 +19,11 @@
public static final int NOT_SPECIFIED = -1;
+ public static <T> Future<T> processAsynchronously(
+ Callable<T> callable, ExecutorService executorService) {
+ return executorService.submit(callable);
+ }
+
public static <T, R, E extends Exception> Collection<R> processItemsWithResults(
Iterable<T> items, ThrowingFunction<T, R, E> consumer, ExecutorService executorService)
throws ExecutionException {
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitor.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitor.java
index a0b2104..90e3b16 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitor.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitor.java
@@ -37,10 +37,7 @@
public final <S extends StructuralItem<S>> int visitItemCollection(
Collection<S> items1, Collection<S> items2) {
- return visitItemIterator(
- items1.iterator(),
- items2.iterator(),
- (s, other, visitor) -> s.acceptCompareTo(other, visitor));
+ return visitItemIterator(items1.iterator(), items2.iterator(), StructuralItem::acceptCompareTo);
}
public abstract int visitDexString(DexString string1, DexString string2);
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
index 234732c..c721599 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorBase.java
@@ -18,29 +18,39 @@
/** Base class to share most visiting methods */
public abstract class CompareToVisitorBase extends CompareToVisitor {
+ private static boolean DEBUG = false;
+
+ // Helper to debug insert a breakpoint on order values.
+ public static int debug(int order) {
+ if (DEBUG && order != 0) {
+ return order;
+ }
+ return order;
+ }
+
@Override
public final int visitBool(boolean value1, boolean value2) {
- return Boolean.compare(value1, value2);
+ return debug(Boolean.compare(value1, value2));
}
@Override
public final int visitInt(int value1, int value2) {
- return Integer.compare(value1, value2);
+ return debug(Integer.compare(value1, value2));
}
@Override
public int visitLong(long value1, long value2) {
- return Long.compare(value1, value2);
+ return debug(Long.compare(value1, value2));
}
@Override
public int visitFloat(float value1, float value2) {
- return Float.compare(value1, value2);
+ return debug(Float.compare(value1, value2));
}
@Override
public int visitDouble(double value1, double value2) {
- return Double.compare(value1, value2);
+ return debug(Double.compare(value1, value2));
}
@Override
@@ -53,12 +63,12 @@
if (order == 0) {
order = visitBool(it1.hasNext(), it2.hasNext());
}
- return order;
+ return debug(order);
}
@Override
public int visitDexString(DexString string1, DexString string2) {
- return string1.compareTo(string2);
+ return debug(string1.compareTo(string2));
}
@Override
@@ -74,19 +84,19 @@
order = visitDexMethod(reference1.asDexMethod(), reference2.asDexMethod());
}
}
- return order;
+ return debug(order);
}
@Override
public final <S> int visit(S item1, S item2, Comparator<S> comparator) {
- return comparator.compare(item1, item2);
+ return debug(comparator.compare(item1, item2));
}
@Override
public final <S> int visit(S item1, S item2, StructuralMapping<S> accept) {
ItemSpecification<S> itemVisitor = new ItemSpecification<>(item1, item2, this);
accept.apply(itemVisitor);
- return itemVisitor.order;
+ return debug(itemVisitor.order);
}
private static class ItemSpecification<T>
@@ -198,7 +208,7 @@
}
@Override
- protected <S> ItemSpecification<T> withItemIterator(
+ protected <S> ItemSpecification<T> withCustomItemIterator(
Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
if (order == 0) {
order = parent.visitItemIterator(getter.apply(item1), getter.apply(item2), compare);
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
index f581065..7569929 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithNamingLens.java
@@ -29,34 +29,35 @@
@Override
public int visitDexType(DexType type1, DexType type2) {
- return namingLens
- .lookupDescriptor(type1)
- .acceptCompareTo(namingLens.lookupDescriptor(type2), this);
+ return debug(
+ namingLens
+ .lookupDescriptor(type1)
+ .acceptCompareTo(namingLens.lookupDescriptor(type2), this));
}
@Override
public int visitDexField(DexField field1, DexField field2) {
int order = field1.holder.acceptCompareTo(field2.holder, this);
if (order != 0) {
- return order;
+ return debug(order);
}
order = namingLens.lookupName(field1).acceptCompareTo(namingLens.lookupName(field2), this);
if (order != 0) {
- return order;
+ return debug(order);
}
- return field1.type.acceptCompareTo(field2.type, this);
+ return debug(field1.type.acceptCompareTo(field2.type, this));
}
@Override
public int visitDexMethod(DexMethod method1, DexMethod method2) {
int order = method1.holder.acceptCompareTo(method2.holder, this);
if (order != 0) {
- return order;
+ return debug(order);
}
order = namingLens.lookupName(method1).acceptCompareTo(namingLens.lookupName(method2), this);
if (order != 0) {
- return order;
+ return debug(order);
}
- return method1.proto.acceptCompareTo(method2.proto, this);
+ return debug(method1.proto.acceptCompareTo(method2.proto, this));
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
index 89bd02b..ccb5c9e 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/CompareToVisitorWithTypeEquivalence.java
@@ -28,6 +28,6 @@
public int visitDexType(DexType type1, DexType type2) {
DexType repr1 = representatives.getRepresentative(type1);
DexType repr2 = representatives.getRepresentative(type2);
- return repr1.getDescriptor().acceptCompareTo(repr2.getDescriptor(), this);
+ return debug(repr1.getDescriptor().acceptCompareTo(repr2.getDescriptor(), this));
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java b/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
index 892183d..244d404 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/HashCodeVisitor.java
@@ -105,7 +105,7 @@
}
@Override
- protected <S> HashCodeVisitor<T> withItemIterator(
+ protected <S> HashCodeVisitor<T> withCustomItemIterator(
Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
Iterator<S> it = getter.apply(item);
while (it.hasNext()) {
diff --git a/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java b/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
index e63ac6c..6c388fb 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/HashingVisitorWithTypeEquivalence.java
@@ -170,7 +170,7 @@
}
@Override
- protected <S> ItemSpecification<T> withItemIterator(
+ protected <S> ItemSpecification<T> withCustomItemIterator(
Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher) {
parent.visitItemIterator(getter.apply(item), hasher);
return this;
diff --git a/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java b/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
index a81fc18..69d8796 100644
--- a/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
+++ b/src/main/java/com/android/tools/r8/utils/structural/StructuralSpecification.java
@@ -51,12 +51,12 @@
HashingAccept<S> hasher);
/** Base implementation for visiting an enumeration of items. */
- protected abstract <S> V withItemIterator(
+ protected abstract <S> V withCustomItemIterator(
Function<T, Iterator<S>> getter, CompareToAccept<S> compare, HashingAccept<S> hasher);
public final <S> V withCustomItemCollection(
Function<T, Collection<S>> getter, StructuralAcceptor<S> acceptor) {
- return withItemIterator(getter.andThen(Collection::iterator), acceptor, acceptor);
+ return withCustomItemIterator(getter.andThen(Collection::iterator), acceptor, acceptor);
}
/**
@@ -79,24 +79,23 @@
predicate, getter, StructuralItem::acceptCompareTo, StructuralItem::acceptHashing);
}
+ public final <S extends StructuralItem<S>> V withItemIterator(Function<T, Iterator<S>> getter) {
+ return withCustomItemIterator(
+ getter, StructuralItem::acceptCompareTo, StructuralItem::acceptHashing);
+ }
+
public final <S extends StructuralItem<S>> V withItemCollection(
Function<T, Collection<S>> getter) {
- return withItemIterator(
- getter.andThen(Collection::iterator),
- StructuralItem::acceptCompareTo,
- StructuralItem::acceptHashing);
+ return withItemIterator(getter.andThen(Collection::iterator));
}
public final <S extends StructuralItem<S>> V withItemArray(Function<T, S[]> getter) {
- return withItemIterator(
- getter.andThen(a -> Arrays.asList(a).iterator()),
- StructuralItem::acceptCompareTo,
- StructuralItem::acceptHashing);
+ return withItemIterator(getter.andThen(a -> Arrays.asList(a).iterator()));
}
public final <S extends StructuralItem<S>> V withItemArrayAllowingNullMembers(
Function<T, S[]> getter) {
- return withItemIterator(
+ return withCustomItemIterator(
getter.andThen(a -> Arrays.asList(a).iterator()),
(a, b, visitor) -> {
if (a == null || b == null) {
diff --git a/src/main/keep.txt b/src/main/keep.txt
index 82f6965..24d0fbc 100644
--- a/src/main/keep.txt
+++ b/src/main/keep.txt
@@ -26,3 +26,8 @@
# Compatibility command line program used by the Android Platform build.
-keep public class com.android.tools.r8.compatproguard.CompatProguard { public static void main(java.lang.String[]); }
+
+# TODO(b/176783536): Avoid need to use -dontwarn.
+-dontwarn com.google.errorprone.annotations.**
+-dontwarn com.google.j2objc.annotations.*
+-dontwarn javax.annotation.Nullable
diff --git a/src/test/examplesAndroidO/multidex004/ref-list-1.txt b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
index ac6e888..c817c33 100644
--- a/src/test/examplesAndroidO/multidex004/ref-list-1.txt
+++ b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
@@ -1,4 +1,4 @@
-Lmultidex004/-$$Lambda$MainActivity$g120D_43GXrTOaB3kfYt6wSIJh4;
+Lmultidex004/MainActivity-$$ExternalSyntheticLambda0;
Lmultidex004/MainActivity;
Lmultidex004/VersionInterface;
Lmultidex004/VersionStatic;
diff --git a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
index d25c465..82cfebf 100644
--- a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
@@ -13,9 +13,9 @@
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
-import com.android.tools.r8.ir.desugar.LambdaRewriter;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -93,11 +93,12 @@
for (String descriptor : descriptors) {
// classes are either lambda classes used by the main class, companion classes of the main
// interface, the main class/interface, or for JDK9, desugaring of try-with-resources.
+ ClassReference reference = Reference.classFromDescriptor(descriptor);
Assert.assertTrue(
- descriptor.contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX)
- || descriptor.endsWith(InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX + ";")
- || descriptor.equals(TwrCloseResourceRewriter.UTILITY_CLASS_DESCRIPTOR)
- || descriptor.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
+ descriptor.endsWith(InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX + ";")
+ || SyntheticItemsTestUtils.isExternalTwrCloseMethod(reference)
+ || SyntheticItemsTestUtils.isExternalLambda(reference)
+ || SyntheticItemsTestUtils.isExternalStaticInterfaceCall(reference)
|| descriptor.equals(mainClassDescriptor));
}
String classDescriptor =
diff --git a/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
index 1d9ec50..78bbcf3 100644
--- a/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
@@ -92,9 +92,7 @@
// Build each class individually using tmpClassesDir as classpath for desugaring.
List<ProgramResource> individalDexes = new ArrayList<>();
List<Path> individualClassFiles =
- Files.walk(tmpClassesDir)
- .filter(classFile -> FileUtils.isClassFile(classFile))
- .collect(Collectors.toList());
+ Files.walk(tmpClassesDir).filter(FileUtils::isClassFile).collect(Collectors.toList());
for (Path classFile : individualClassFiles) {
D8Command.Builder builder =
D8Command.builder()
diff --git a/src/test/java/com/android/tools/r8/D8TestCompileResult.java b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
index 1fcd0e7..b5fccb8 100644
--- a/src/test/java/com/android/tools/r8/D8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
@@ -4,7 +4,9 @@
package com.android.tools.r8;
import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.utils.AndroidApp;
+import java.util.Set;
public class D8TestCompileResult extends TestCompileResult<D8TestCompileResult, D8TestRunResult> {
D8TestCompileResult(TestState state, AndroidApp app, int minApiLevel, OutputMode outputMode) {
@@ -22,6 +24,11 @@
}
@Override
+ public Set<String> getMainDexClasses() {
+ throw new Unimplemented();
+ }
+
+ @Override
public String getStdout() {
return state.getStdout();
}
diff --git a/src/test/java/com/android/tools/r8/DXTestCompileResult.java b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
index 4a0c42f..a3cf644 100644
--- a/src/test/java/com/android/tools/r8/DXTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
@@ -6,6 +6,7 @@
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.utils.AndroidApp;
+import java.util.Set;
public class DXTestCompileResult extends TestCompileResult<DXTestCompileResult, DXTestRunResult> {
@@ -24,6 +25,11 @@
}
@Override
+ public Set<String> getMainDexClasses() {
+ throw new Unimplemented();
+ }
+
+ @Override
public String getStdout() {
throw new Unimplemented("Unexpected attempt to access stdout from dx");
}
diff --git a/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
index a7c0baf..cef49f7 100644
--- a/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
@@ -5,10 +5,12 @@
package com.android.tools.r8;
import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.io.IOException;
import java.nio.file.Path;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
public class ExternalR8TestCompileResult
@@ -51,6 +53,11 @@
}
@Override
+ public Set<String> getMainDexClasses() {
+ throw new Unimplemented();
+ }
+
+ @Override
public String getStdout() {
return processResult.stdout;
}
diff --git a/src/test/java/com/android/tools/r8/Keep.java b/src/test/java/com/android/tools/r8/Keep.java
new file mode 100644
index 0000000..ed8275b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/Keep.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+public @interface Keep {}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
index 0e65de1..7aacf12 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -53,6 +53,11 @@
}
@Override
+ public boolean isProguardTestBuilder() {
+ return true;
+ }
+
+ @Override
ProguardTestBuilder self() {
return this;
}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
index c352417..ca1a0a7 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.io.IOException;
import java.nio.file.Path;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
public class ProguardTestCompileResult
@@ -42,6 +43,11 @@
}
@Override
+ public Set<String> getMainDexClasses() {
+ throw new Unimplemented();
+ }
+
+ @Override
public String getStdout() {
throw new Unimplemented("Unexpected attempt to access stdout from Proguard");
}
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index 4dc03b1..f22a173 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -741,8 +741,20 @@
.put(
"095-switch-MAX_INT",
TestCondition.match(
+ TestCondition.tools(DexTool.NONE),
+ TestCondition.compilers(CompilerUnderTest.D8_AFTER_R8CF),
+ TestCondition.runtimes(DexVm.Version.V4_0_4)))
+ .put(
+ "095-switch-MAX_INT",
+ TestCondition.match(
+ TestCondition.tools(DexTool.NONE),
+ TestCondition.compilers(CompilerUnderTest.D8),
+ TestCondition.runtimes(DexVm.Version.V4_0_4)))
+ .put(
+ "095-switch-MAX_INT",
+ TestCondition.match(
TestCondition.tools(DexTool.DX),
- TestCondition.D8_COMPILER,
+ TestCondition.compilers(CompilerUnderTest.D8),
TestCondition.runtimes(DexVm.Version.V4_0_4)))
.build();
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index 7157943..389b0fa 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -107,14 +107,14 @@
.withOptionConsumer(opts -> opts.enableClassInlining = false)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 101, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 102, "lambdadesugaring"))
.run();
test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
.withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
.run();
}
@@ -146,14 +146,14 @@
.withOptionConsumer(opts -> opts.enableClassInlining = false)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 101, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 102, "lambdadesugaring"))
.run();
test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
.withMinApiLevel(AndroidApiLevel.N)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
.run();
}
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
index 23ec0c9..8a004a9 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
@@ -169,6 +169,7 @@
protected void configure(InternalOptions options) {
options.lineNumberOptimization = LineNumberOptimization.OFF;
+ options.testing.allowDexInputForTesting = input == Input.DX;
}
private boolean shouldCompileFail() {
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index e831d72..909d45e 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -244,10 +244,6 @@
return self();
}
- public T allowClassInlinerGracefulExit() {
- return addOptionsModification(options -> options.testing.allowClassInlinerGracefulExit = true);
- }
-
/**
* Allow info, warning, and error diagnostics.
*
@@ -314,6 +310,10 @@
return self();
}
+ public T allowUnusedDontWarnPatterns() {
+ return addOptionsModification(options -> options.testing.allowUnusedDontWarnRules = true);
+ }
+
public T allowUnusedProguardConfigurationRules() {
return allowUnusedProguardConfigurationRules(true);
}
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 9b63b86..c9834f8 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -21,6 +21,7 @@
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
+import java.util.Set;
import java.util.function.Consumer;
public class R8TestCompileResult extends TestCompileResult<R8TestCompileResult, R8TestRunResult> {
@@ -74,6 +75,11 @@
}
@Override
+ public Set<String> getMainDexClasses() {
+ return state.getMainDexClasses();
+ }
+
+ @Override
public String getStdout() {
return state.getStdout();
}
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
index c72a3ea..b7bb5d2 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
@@ -611,14 +611,15 @@
Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
boolean expectedToFail = expectedToFail(testName);
try {
- String output = ToolHelper.runArtNoVerificationErrors(
- Arrays.stream(dexes).map(path -> path.toString()).collect(Collectors.toList()),
- qualifiedMainClass,
- builder -> {
- for (String arg : args) {
- builder.appendProgramArgument(arg);
- }
- });
+ String output =
+ ToolHelper.runArtNoVerificationErrors(
+ Arrays.stream(dexes).map(Path::toString).collect(Collectors.toList()),
+ qualifiedMainClass,
+ builder -> {
+ for (String arg : args) {
+ builder.appendProgramArgument(arg);
+ }
+ });
if (!expectedToFail
&& !skipRunningOnJvm(testName)
&& !ToolHelper.compareAgaintsGoldenFiles()) {
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
index d06d976..ed69ecf 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
@@ -248,10 +248,11 @@
if (expectedToFail) {
thrown.expect(Throwable.class);
}
- String output = ToolHelper.runArtNoVerificationErrors(
- Arrays.stream(dexes).map(path -> path.toString()).collect(Collectors.toList()),
- qualifiedMainClass,
- null);
+ String output =
+ ToolHelper.runArtNoVerificationErrors(
+ Arrays.stream(dexes).map(Path::toString).collect(Collectors.toList()),
+ qualifiedMainClass,
+ null);
if (!expectedToFail) {
ToolHelper.ProcessResult javaResult =
ToolHelper.runJava(ImmutableList.copyOf(jars), qualifiedMainClass);
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index e1d4c9e..f6846b4 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -49,7 +49,6 @@
import com.android.tools.r8.shaking.MainDexClasses;
import com.android.tools.r8.shaking.NoStaticClassMergingRule;
import com.android.tools.r8.shaking.NoVerticalClassMergingRule;
-import com.android.tools.r8.shaking.ProguardClassFilter;
import com.android.tools.r8.shaking.ProguardClassNameList;
import com.android.tools.r8.shaking.ProguardConfiguration;
import com.android.tools.r8.shaking.ProguardConfigurationRule;
@@ -720,9 +719,9 @@
MainDexClasses.createEmptyMainDexClasses());
}
- protected static AppView<AppInfoWithClassHierarchy> computeAppViewWithSubtyping(AndroidApp app)
- throws Exception {
- return computeAppViewWithSubtyping(
+ protected static AppView<AppInfoWithClassHierarchy> computeAppViewWithClassHierachy(
+ AndroidApp app) throws Exception {
+ return computeAppViewWithClassHierachy(
app,
factory ->
buildConfigForRules(
@@ -730,7 +729,7 @@
Collections.singletonList(ProguardKeepRule.defaultKeepAllRule(unused -> {}))));
}
- private static AppView<AppInfoWithClassHierarchy> computeAppViewWithSubtyping(
+ private static AppView<AppInfoWithClassHierarchy> computeAppViewWithClassHierachy(
AndroidApp app, Function<DexItemFactory, ProguardConfiguration> keepConfig) throws Exception {
DexItemFactory dexItemFactory = new DexItemFactory();
InternalOptions options = new InternalOptions(keepConfig.apply(dexItemFactory), new Reporter());
@@ -759,7 +758,7 @@
protected static AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
AndroidApp app, Function<DexItemFactory, ProguardConfiguration> keepConfig) throws Exception {
- AppView<AppInfoWithClassHierarchy> appView = computeAppViewWithSubtyping(app, keepConfig);
+ AppView<AppInfoWithClassHierarchy> appView = computeAppViewWithClassHierachy(app, keepConfig);
// Run the tree shaker to compute an instance of AppInfoWithLiveness.
ExecutorService executor = Executors.newSingleThreadExecutor();
SubtypingInfo subtypingInfo = new SubtypingInfo(appView);
@@ -769,8 +768,8 @@
.run(executor);
appView.setRootSet(rootSet);
AppInfoWithLiveness appInfoWithLiveness =
- EnqueuerFactory.createForInitialTreeShaking(appView, subtypingInfo)
- .traceApplication(rootSet, ProguardClassFilter.empty(), executor, Timing.empty());
+ EnqueuerFactory.createForInitialTreeShaking(appView, executor, subtypingInfo)
+ .traceApplication(rootSet, executor, Timing.empty());
// We do not run the tree pruner to ensure that the hierarchy is as designed and not modified
// due to liveness.
return appView.setAppInfo(appInfoWithLiveness);
@@ -1702,6 +1701,10 @@
return AndroidApiLevel.L;
}
+ public static AndroidApiLevel apiLevelWithTwrCloseResourceSupport() {
+ return AndroidApiLevel.K;
+ }
+
public static boolean canUseJavaUtilObjects(TestParameters parameters) {
return parameters.isCfRuntime()
|| parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
diff --git a/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java b/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
index 06cba56..d917ab6 100644
--- a/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
+++ b/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
@@ -28,7 +28,10 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+ .build();
}
public TestBuilderMinAndroidJarTest(TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index e37e48e..64c7680 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -38,6 +38,7 @@
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Function;
@@ -90,6 +91,13 @@
return self();
}
+ public abstract Set<String> getMainDexClasses();
+
+ public final CR inspectMainDexClasses(Consumer<Set<String>> consumer) {
+ consumer.accept(getMainDexClasses());
+ return self();
+ }
+
public abstract String getStdout();
public abstract String getStderr();
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index f196151..79f00e2 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.AndroidAppConsumers;
+import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.ForwardingOutputStream;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.ThrowingOutputStream;
@@ -30,10 +31,13 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
public abstract class TestCompilerBuilder<
C extends BaseCompilerCommand,
@@ -45,7 +49,9 @@
public static final Consumer<InternalOptions> DEFAULT_OPTIONS =
options -> {
- options.testing.allowClassInlinerGracefulExit = false;
+ options.testing.allowUnusedDontWarnRules = false;
+ options.testing.allowUnnecessaryDontWarnWildcards = false;
+ options.testing.enableExperimentalMissingClassesReporting = true;
options.testing.reportUnusedProguardConfigurationRules = true;
options.horizontalClassMergerOptions().enable();
};
@@ -58,6 +64,7 @@
private boolean useDefaultRuntimeLibrary = true;
private final List<Path> additionalRunClassPath = new ArrayList<>();
private ProgramConsumer programConsumer;
+ private MainDexClassesCollector mainDexClassesCollector;
private StringConsumer mainDexListConsumer;
protected int minApiLevel = ToolHelper.getMinApiLevelForDexVm().getLevel();
private Consumer<InternalOptions> optionsConsumer = DEFAULT_OPTIONS;
@@ -172,7 +179,13 @@
public CR compile() throws CompilationFailedException {
AndroidAppConsumers sink = new AndroidAppConsumers();
builder.setProgramConsumer(sink.wrapProgramConsumer(programConsumer));
- builder.setMainDexListConsumer(mainDexListConsumer);
+ if (mainDexClassesCollector != null || mainDexListConsumer != null) {
+ builder.setMainDexListConsumer(
+ ChainedStringConsumer.builder()
+ .addIfNotNull(mainDexClassesCollector)
+ .addIfNotNull(mainDexListConsumer)
+ .build());
+ }
if (backend.isDex() || !isTestShrinkerBuilder()) {
assert !builder.isMinApiLevelSet()
: "Don't set the API level directly through BaseCompilerCommand.Builder in tests";
@@ -188,6 +201,7 @@
builder.addLibraryFiles(TestBase.runtimeJar(backend));
}
}
+ List<String> mainDexClasses = null;
assertNull(oldStdout);
oldStdout = System.out;
assertNull(oldStderr);
@@ -220,6 +234,9 @@
}
return cr;
} finally {
+ if (mainDexClassesCollector != null) {
+ getState().setMainDexClasses(mainDexClassesCollector.getMainDexClasses());
+ }
if (stdout != null) {
getState().setStdout(stdout.toString());
}
@@ -372,6 +389,12 @@
return self();
}
+ public T collectMainDexClasses() {
+ assert mainDexClassesCollector == null;
+ mainDexClassesCollector = new MainDexClassesCollector();
+ return self();
+ }
+
public T setMainDexListConsumer(StringConsumer consumer) {
assert consumer != null;
this.mainDexListConsumer = consumer;
@@ -467,4 +490,76 @@
builder.addAssertionsConfiguration(assertionsConfigurationGenerator);
return self();
}
+
+ private static class ChainedStringConsumer implements StringConsumer {
+
+ private final List<StringConsumer> consumers;
+
+ ChainedStringConsumer(List<StringConsumer> consumers) {
+ this.consumers = consumers;
+ }
+
+ static Builder builder() {
+ return new Builder();
+ }
+
+ @Override
+ public void accept(String string, DiagnosticsHandler handler) {
+ consumers.forEach(consumer -> consumer.accept(string, handler));
+ }
+
+ @Override
+ public void finished(DiagnosticsHandler handler) {
+ consumers.forEach(consumer -> consumer.finished(handler));
+ }
+
+ static class Builder {
+
+ private final List<StringConsumer> consumers = new ArrayList<>();
+
+ Builder add(StringConsumer consumer) {
+ assert consumer != null;
+ consumers.add(consumer);
+ return this;
+ }
+
+ Builder addIfNotNull(StringConsumer consumer) {
+ return consumer != null ? add(consumer) : this;
+ }
+
+ ChainedStringConsumer build() {
+ return new ChainedStringConsumer(consumers);
+ }
+ }
+ }
+
+ private static class MainDexClassesCollector implements StringConsumer {
+
+ private StringBuilder builder = new StringBuilder();
+ private Set<String> mainDexClasses;
+
+ public Set<String> getMainDexClasses() {
+ assert mainDexClasses != null;
+ return mainDexClasses;
+ }
+
+ @Override
+ public void accept(String string, DiagnosticsHandler handler) {
+ builder.append(string);
+ }
+
+ @Override
+ public void finished(DiagnosticsHandler handler) {
+ mainDexClasses =
+ Stream.of(builder.toString().split(System.lineSeparator()))
+ .map(
+ line -> {
+ assert line.endsWith(".class");
+ return line.substring(0, line.length() - ".class".length());
+ })
+ .map(DescriptorUtils::getJavaTypeFromBinaryName)
+ .collect(Collectors.toSet());
+ builder = null;
+ }
+ }
}
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
index 72a22e6..4f8713f 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static org.hamcrest.CoreMatchers.not;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@@ -64,6 +65,11 @@
return assertWarningsMatch(Collections.singletonList(matcher));
}
+ @SuppressWarnings("unchecked")
+ default TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic>... matchers) {
+ return assertWarningsMatch(Arrays.asList(matchers));
+ }
+
TestDiagnosticMessages assertWarningsMatch(Collection<Matcher<Diagnostic>> matchers);
default TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic> matcher) {
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
index 3935988..f1b6e73 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
@@ -92,7 +92,7 @@
"Expected no "
+ type
+ " messages, got:\n"
- + String.join("\n", ListUtils.map(messages, m -> m.getDiagnosticMessage())),
+ + String.join("\n", ListUtils.map(messages, Diagnostic::getDiagnosticMessage)),
0,
messages.size());
}
diff --git a/src/test/java/com/android/tools/r8/TestParametersBuilder.java b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
index 9b84425..c5811f9 100644
--- a/src/test/java/com/android/tools/r8/TestParametersBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
@@ -75,12 +75,12 @@
/** Add all available CF runtimes starting from and including {@param startInclusive}. */
public TestParametersBuilder withCfRuntimesStartingFromIncluding(CfVm startInclusive) {
- return withCfRuntimeFilter(vm -> startInclusive.lessThanOrEqual(vm));
+ return withCfRuntimeFilter(startInclusive::lessThanOrEqual);
}
/** Add all available CF runtimes starting from and excluding {@param startExcluding}. */
public TestParametersBuilder withCfRuntimesStartingFromExcluding(CfVm startExcluding) {
- return withCfRuntimeFilter(vm -> startExcluding.lessThan(vm));
+ return withCfRuntimeFilter(startExcluding::lessThan);
}
/** Add all available CF runtimes ending at and including {@param endInclusive}. */
@@ -115,9 +115,14 @@
return withDexRuntimesStartingFromIncluding(DexVm.Version.V5_1_1);
}
+ /** Add all available DEX runtimes that do not support native multidex. */
+ public TestParametersBuilder withMainDexRuntimes() {
+ return withDexRuntimesEndingAtExcluding(DexVm.Version.V5_1_1);
+ }
+
/** Add all available DEX runtimes starting from and including {@param startInclusive}. */
public TestParametersBuilder withDexRuntimesStartingFromIncluding(DexVm.Version startInclusive) {
- return withDexRuntimeFilter(vm -> startInclusive.isOlderThanOrEqual(vm));
+ return withDexRuntimeFilter(startInclusive::isOlderThanOrEqual);
}
/** Add all available DEX runtimes starting from and excluding {@param startExcluding}. */
diff --git a/src/test/java/com/android/tools/r8/TestParametersCollection.java b/src/test/java/com/android/tools/r8/TestParametersCollection.java
index 52bc8d5..8351a9c 100644
--- a/src/test/java/com/android/tools/r8/TestParametersCollection.java
+++ b/src/test/java/com/android/tools/r8/TestParametersCollection.java
@@ -6,7 +6,6 @@
import java.util.Collection;
import java.util.Iterator;
import java.util.stream.Stream;
-import org.jetbrains.annotations.NotNull;
public class TestParametersCollection implements Iterable<TestParameters> {
@@ -17,7 +16,6 @@
this.parameters = parameters;
}
- @NotNull
@Override
public Iterator<TestParameters> iterator() {
return parameters.iterator();
diff --git a/src/test/java/com/android/tools/r8/TestRunResult.java b/src/test/java/com/android/tools/r8/TestRunResult.java
index c775215..4a7d5c7 100644
--- a/src/test/java/com/android/tools/r8/TestRunResult.java
+++ b/src/test/java/com/android/tools/r8/TestRunResult.java
@@ -66,8 +66,12 @@
}
public RR assertSuccessWithOutputLinesIf(boolean condition, String... expected) {
+ return assertSuccessWithOutputLinesIf(condition, Arrays.asList(expected));
+ }
+
+ public RR assertSuccessWithOutputLinesIf(boolean condition, List<String> expected) {
if (condition) {
- return assertSuccessWithOutputLines(Arrays.asList(expected));
+ return assertSuccessWithOutputLines(expected);
}
return self();
}
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index 1bcbc55..b28a51f 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -4,6 +4,8 @@
package com.android.tools.r8;
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
+
import com.android.tools.r8.TestBase.Backend;
import com.android.tools.r8.dexsplitter.SplitterTestBase.RunInterface;
import com.android.tools.r8.references.MethodReference;
@@ -40,6 +42,10 @@
super(state, builder, backend);
}
+ public boolean isProguardTestBuilder() {
+ return false;
+ }
+
@Override
public boolean isTestShrinkerBuilder() {
return true;
@@ -90,7 +96,7 @@
public abstract T addKeepRuleFiles(List<Path> files);
- public T addKeepRuleFiles(Path... files) throws IOException {
+ public T addKeepRuleFiles(Path... files) {
return addKeepRuleFiles(Arrays.asList(files));
}
@@ -101,7 +107,150 @@
}
public T addDontWarn(Class<?> clazz) {
- return addKeepRules("-dontwarn " + clazz.getTypeName());
+ return addDontWarn(clazz.getTypeName());
+ }
+
+ public T addDontWarn(String className) {
+ return addKeepRules("-dontwarn " + className);
+ }
+
+ public T addDontWarn(String... classes) {
+ for (String clazz : classes) {
+ addKeepRules("-dontwarn " + clazz);
+ }
+ return self();
+ }
+
+ @Deprecated
+ public T addDontWarnCompanionClass(Class<?> clazz) {
+ return addDontWarn(clazz.getTypeName() + COMPANION_CLASS_NAME_SUFFIX);
+ }
+
+ @Deprecated
+ public T addDontWarnCompanionClasses() {
+ return addDontWarn("**" + COMPANION_CLASS_NAME_SUFFIX);
+ }
+
+ @Deprecated
+ public T addDontWarnCompilerSynthesizedAnnotations() {
+ return addDontWarnCompilerSynthesizedClassAnnotation()
+ .addDontWarnCompilerSynthesizedClassMapAnnotation();
+ }
+
+ @Deprecated
+ public T addDontWarnCompilerSynthesizedClassAnnotation() {
+ return addDontWarn("com.android.tools.r8.annotations.SynthesizedClass");
+ }
+
+ @Deprecated
+ public T addDontWarnCompilerSynthesizedClassMapAnnotation() {
+ return addDontWarn("com.android.tools.r8.annotations.SynthesizedClassMap");
+ }
+
+ // TODO(b/176143558): Should not report missing classes for compiler synthesized classes.
+ @Deprecated
+ public T addDontWarnEmulatedLibraryClass(Class<?> clazz) {
+ return addDontWarn(clazz.getTypeName() + "$-EL");
+ }
+
+ // TODO(b/176143558): Should not report missing classes for compiler synthesized classes.
+ @Deprecated
+ public T addDontWarnEmulatedLibraryClasses() {
+ return addDontWarn("**$-EL");
+ }
+
+ public T addDontWarnGoogle() {
+ return addDontWarn("com.google.**");
+ }
+
+ public T addDontWarnJavax() {
+ return addDontWarn("javax.**");
+ }
+
+ public T addDontWarnJavaxNullableAnnotation() {
+ return addDontWarn("javax.annotation.Nullable");
+ }
+
+ public T addDontWarnJavaLangInvoke() {
+ return addDontWarn("java.lang.invoke.*");
+ }
+
+ public T addDontWarnJavaLangInvoke(String className) {
+ return addDontWarn("java.lang.invoke." + className);
+ }
+
+ public T addDontWarnJavaNioFile() {
+ return addDontWarn("java.nio.file.**");
+ }
+
+ // TODO(b/176133676): Investigate why there are missing class references to org.jetbrains
+ @Deprecated
+ public T addDontWarnJetBrains() {
+ return addDontWarn("org.jetbrains.**");
+ }
+
+ public T addDontWarnJetBrainsAnnotations() {
+ return addDontWarnJetBrainsNotNullAnnotation().addDontWarnJetBrainsNullableAnnotation();
+ }
+
+ public T addDontWarnJetBrainsNotNullAnnotation() {
+ return addDontWarn("org.jetbrains.annotations.NotNull");
+ }
+
+ public T addDontWarnJetBrainsNullableAnnotation() {
+ return addDontWarn("org.jetbrains.annotations.Nullable");
+ }
+
+ // TODO(b/176133676): Should not report missing classes for Kotlin classes.
+ @Deprecated
+ public T addDontWarnKotlin() {
+ return addDontWarn("kotlin.**");
+ }
+
+ // TODO(b/176133676): Should not report missing classes for Kotlin metadata.
+ @Deprecated
+ public T addDontWarnKotlinMetadata() {
+ return addDontWarn("kotlin.Metadata");
+ }
+
+ // TODO(b/176133676): Investigate kotlinx missing class references.
+ @Deprecated
+ public T addDontWarnKotlinx() {
+ return addDontWarn("kotlinx.**");
+ }
+
+ // TODO(b/176144018): Should not report compiler synthesized references as missing.
+ @Deprecated
+ public T addDontWarnRetargetLibraryMembers() {
+ return addDontWarn("j$.retarget.$r8$retargetLibraryMember**");
+ }
+
+ @Deprecated
+ public T addDontWarnRetargetLibraryMember(String suffix) {
+ return addDontWarn("j$.retarget.$r8$retargetLibraryMember$" + suffix);
+ }
+
+ // TODO(b/154849103): Should not warn about SerializedLambda.
+ @Deprecated
+ public T addDontWarnSerializedLambda() {
+ return addDontWarn("java.lang.invoke.SerializedLambda");
+ }
+
+ // TODO(b/176781593): Should not be reported missing.
+ @Deprecated
+ public T addDontWarnTimeConversions() {
+ return addDontWarn("java.time.TimeConversions");
+ }
+
+ // TODO(b/176144018): Should not report compiler synthesized references as missing.
+ @Deprecated
+ public T addDontWarnVivifiedClass(Class<?> clazz) {
+ return addDontWarn("$-vivified-$." + clazz.getTypeName());
+ }
+
+ @Deprecated
+ public T addDontWarnVivifiedClasses() {
+ return addDontWarn("$-vivified-$.**");
}
public T addKeepKotlinMetadata() {
@@ -327,6 +476,10 @@
return addTestingAnnotation(NeverInline.class);
}
+ public final T addKeepAnnotation() {
+ return addTestingAnnotation(Keep.class);
+ }
+
public final T addMemberValuePropagationAnnotations() {
return addTestingAnnotation(NeverPropagateValue.class);
}
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
index 3e28699..a30033b 100644
--- a/src/test/java/com/android/tools/r8/TestState.java
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -5,6 +5,7 @@
import java.io.IOException;
import java.nio.file.Path;
+import java.util.Set;
import java.util.function.BiFunction;
import org.junit.rules.TemporaryFolder;
@@ -13,6 +14,8 @@
private final TemporaryFolder temp;
private final TestDiagnosticMessagesImpl messages = new TestDiagnosticMessagesImpl();
+ private Set<String> mainDexClasses;
+
private String stdout;
private String stderr;
@@ -40,6 +43,14 @@
return messages;
}
+ public Set<String> getMainDexClasses() {
+ return mainDexClasses;
+ }
+
+ void setMainDexClasses(Set<String> mainDexClasses) {
+ this.mainDexClasses = mainDexClasses;
+ }
+
public String getStdout() {
return stdout;
}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index a85ae6a..08664a8 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -510,7 +510,7 @@
}
private static List<File> toFileList(List<String> filePathList) {
- return filePathList.stream().map(path -> new File(path)).collect(Collectors.toList());
+ return filePathList.stream().map(File::new).collect(Collectors.toList());
}
public static class DXCommandBuilder extends CommandBuilder {
@@ -1541,7 +1541,7 @@
assert goldenFileDir.isDirectory();
processResult =
compareAgainstGoldenFiles(
- files.stream().map(f -> new File(f)).collect(Collectors.toList()), goldenFileDir);
+ files.stream().map(File::new).collect(Collectors.toList()), goldenFileDir);
if (processResult.exitCode == 0) {
processResult = readProcessResult(goldenFileDir);
}
@@ -1553,8 +1553,7 @@
if (goldenFilesDirToProp != null) {
File goldenFileDir = new File(goldenFilesDirToProp);
assert goldenFileDir.isDirectory();
- storeAsGoldenFiles(
- files.stream().map(f -> new File(f)).collect(Collectors.toList()), goldenFileDir);
+ storeAsGoldenFiles(files.stream().map(File::new).collect(Collectors.toList()), goldenFileDir);
storeProcessResult(processResult, goldenFileDir);
}
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationTestBase.java b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationTestBase.java
index ce40a93..1127d82 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationTestBase.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/AccessRelaxationTestBase.java
@@ -23,7 +23,7 @@
this.parameters = parameters;
}
- static void assertPublic(CodeInspector codeInspector, Class clazz, MethodSignature signature) {
+ static void assertPublic(CodeInspector codeInspector, Class<?> clazz, MethodSignature signature) {
ClassSubject classSubject = codeInspector.clazz(clazz);
assertThat(classSubject, isPresent());
MethodSubject methodSubject = classSubject.method(signature);
@@ -31,12 +31,12 @@
assertThat(methodSubject, isPublic());
}
- static void assertNotPublic(CodeInspector codeInspector, Class clazz, MethodSignature signature) {
+ static void assertNotPublic(
+ CodeInspector codeInspector, Class<?> clazz, MethodSignature signature) {
ClassSubject classSubject = codeInspector.clazz(clazz);
assertThat(classSubject, isPresent());
MethodSubject methodSubject = classSubject.method(signature);
assertThat(methodSubject, isPresent());
assertThat(methodSubject, not(isPublic()));
}
-
}
diff --git a/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java b/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java
index 83a0155..339361b 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -103,7 +104,11 @@
@Parameterized.Parameters(name = "{0}, access-modification: {1}")
public static List<Object[]> data() {
return buildParameters(
- getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+ getTestParameters()
+ .withAllRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.K)
+ .build(),
+ BooleanUtils.values());
}
public NoRelaxationForSerializableTest(TestParameters parameters, boolean accessModification) {
@@ -141,6 +146,8 @@
R8TestCompileResult result =
testForR8(parameters.getBackend())
.addProgramClasses(CLASSES)
+ .addMemberValuePropagationAnnotations()
+ .addNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.addKeepRuleFiles(configuration)
.addKeepRules(KEEPMEMBER_RULES)
@@ -174,6 +181,7 @@
R8TestCompileResult result =
testForR8(parameters.getBackend())
.addProgramClasses(CLASSES)
+ .addNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
.addKeepRuleFiles(configuration)
diff --git a/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java b/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
index 607f96d..98421ae 100644
--- a/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
+++ b/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
@@ -66,6 +66,7 @@
.addProgramFiles(kotlinSources)
.addKeepAttributes(ProguardKeepAttributes.SOURCE_DEBUG_EXTENSION)
.addKeepAllClassesRule()
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMode(CompilationMode.RELEASE)
.setMinApi(parameters.getApiLevel())
.compile()
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 8bb8e36..902d503 100644
--- a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -26,9 +27,9 @@
@RunWith(Parameterized.class)
public class KeepDeserializeLambdaMethodTestRunner extends TestBase {
- private static final Class TEST_CLASS_CF =
+ private static final Class<?> TEST_CLASS_CF =
com.android.tools.r8.cf.KeepDeserializeLambdaMethodTestCf.class;
- private static final Class TEST_CLASS_DEX =
+ private static final Class<?> TEST_CLASS_DEX =
com.android.tools.r8.cf.KeepDeserializeLambdaMethodTestDex.class;
private static final String EXPECTED =
@@ -89,8 +90,10 @@
// TODO(b/148836254): Support deserialized lambdas without the need of additional rules.
"-keep class * { private static synthetic void lambda$*(); }");
} else {
- builder.noMinification();
- builder.noTreeShaking();
+ builder
+ .applyIf(parameters.isDexRuntime(), TestShrinkerBuilder::addDontWarnSerializedLambda)
+ .noMinification()
+ .noTreeShaking();
}
builder
.run(parameters.getRuntime(), getMainClass())
diff --git a/src/test/java/com/android/tools/r8/cf/MissingClassJoinsToObjectTest.java b/src/test/java/com/android/tools/r8/cf/MissingClassJoinsToObjectTest.java
index 81f1d09..43d02cb 100644
--- a/src/test/java/com/android/tools/r8/cf/MissingClassJoinsToObjectTest.java
+++ b/src/test/java/com/android/tools/r8/cf/MissingClassJoinsToObjectTest.java
@@ -51,6 +51,7 @@
.enableInliningAnnotations()
.addProgramClasses(TestClass.class, A.class)
.addKeepMainRule(TestClass.class)
+ .addDontWarn(B.class)
.setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(getRuntimeClasspath())
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 497a1bf..ee7ff0f 100644
--- a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
+++ b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -53,6 +54,7 @@
.addProgramClasses(getClasses())
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(getMainClass())
+ .applyIf(parameters.isDexRuntime(), TestShrinkerBuilder::addDontWarnSerializedLambda)
.addPrintSeeds()
.allowStdoutMessages()
.noMinification()
diff --git a/src/test/java/com/android/tools/r8/cf/SillyBlockOrderTest.java b/src/test/java/com/android/tools/r8/cf/SillyBlockOrderTest.java
index 4484519..d1e4ef7 100644
--- a/src/test/java/com/android/tools/r8/cf/SillyBlockOrderTest.java
+++ b/src/test/java/com/android/tools/r8/cf/SillyBlockOrderTest.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -53,7 +54,8 @@
try {
MethodSubject method =
inspector.method(TestClass.class.getMethod("doubleConditional", boolean.class));
- assertEquals(expected, method.streamInstructions().filter(i -> i.isGoto()).count());
+ assertEquals(
+ expected, method.streamInstructions().filter(InstructionSubject::isGoto).count());
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
diff --git a/src/test/java/com/android/tools/r8/cf/UnusedMultiNewArrayTest.java b/src/test/java/com/android/tools/r8/cf/UnusedMultiNewArrayTest.java
index 5b9ad45..0820b25 100644
--- a/src/test/java/com/android/tools/r8/cf/UnusedMultiNewArrayTest.java
+++ b/src/test/java/com/android/tools/r8/cf/UnusedMultiNewArrayTest.java
@@ -20,7 +20,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public UnusedMultiNewArrayTest(TestParameters parameters) {
@@ -32,7 +32,8 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class)
.addKeepMainRule(TestClass.class)
- .setMinApi(parameters.getRuntime())
+ .addDontWarn(A.class)
+ .setMinApi(parameters.getApiLevel())
.compile();
}
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardModifyDiagnosticsLevelTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardModifyDiagnosticsLevelTest.java
index bac9468..ffe8230 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardModifyDiagnosticsLevelTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardModifyDiagnosticsLevelTest.java
@@ -18,6 +18,8 @@
import com.android.tools.r8.checkdiscarded.testclasses.Main;
import com.android.tools.r8.checkdiscarded.testclasses.UnusedClass;
import com.android.tools.r8.checkdiscarded.testclasses.UsedClass;
+import com.android.tools.r8.checkdiscarded.testclasses.WillBeGone;
+import com.android.tools.r8.checkdiscarded.testclasses.WillStay;
import com.android.tools.r8.errors.CheckDiscardDiagnostic;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.ImmutableList;
@@ -79,7 +81,8 @@
public void dontFailCompilationOnCheckDiscardedFailure() {
try {
testForR8(Backend.DEX)
- .addProgramClasses(UnusedClass.class, UsedClass.class, Main.class)
+ .addProgramClasses(
+ UnusedClass.class, UsedClass.class, Main.class, WillBeGone.class, WillStay.class)
.addKeepMainRule(Main.class)
.addKeepRules("-checkdiscard class " + UsedClass.class.getTypeName())
.addOptionsModification(this::noInlining)
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
index 61f8917..da2e4cb 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
@@ -46,7 +46,7 @@
}
private void compile(
- Class annotation,
+ Class<?> annotation,
boolean checkMembers,
Consumer<TestDiagnosticMessages> onCompilationFailure) {
R8FullTestBuilder builder = testForR8(Backend.DEX);
@@ -54,7 +54,8 @@
try {
R8TestCompileResult result =
builder
- .addProgramClasses(UnusedClass.class, UsedClass.class, Main.class)
+ .addProgramClasses(
+ UnusedClass.class, UsedClass.class, Main.class, WillBeGone.class, WillStay.class)
.addKeepMainRule(Main.class)
.addKeepRules(checkDiscardRule(checkMembers, annotation))
.minification(minify)
@@ -122,5 +123,4 @@
containsString("is invoked from"))));
compile(WillStay.class, true, check);
}
-
}
diff --git a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
index 363008d..1b68052 100644
--- a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
+++ b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
@@ -195,9 +195,11 @@
public void testWithDontWarn() throws Exception {
testForR8(parameters.getBackend())
.setMinApi(parameters.getApiLevel())
+ .addProgramClasses(TestClass.class)
.addProgramClassFileData(junitClasses)
.addKeepAllClassesRule()
- .addKeepRules("-dontwarn android.test.**")
+ .applyIf(
+ libraryContainsJUnit(), builder -> builder.addKeepRules("-dontwarn android.test.**"))
.addOptionsModification(options -> options.lookupLibraryBeforeProgram = false)
.compile()
.assertNoMessages();
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
index 0ebbb9d..090cb9e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.DataEntryResource;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.DataResourceConsumerForTesting;
@@ -51,9 +50,11 @@
.addHorizontallyMergedClassesInspectorIf(
enableHorizontalClassMerging,
inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addVerticallyMergedClassesInspector(
+ inspector -> inspector.assertMergedIntoSubtype(Parent.class))
.compile()
.run(parameters.getRuntime(), Main.class)
- .assertSuccessWithOutputLines("a", "foo parent", "b")
+ .assertSuccessWithOutputLines("a", "b")
.inspector();
assertThat(codeInspector.clazz(Parent.class), not(isPresent()));
@@ -72,13 +73,7 @@
ImmutableList.of(aClassSubject.getFinalName(), aClassSubject.getFinalName(), newClassName));
}
- @NeverClassInline
- public static class Parent {
- @NeverInline
- public void foo() {
- System.out.println("foo parent");
- }
- }
+ public static class Parent {}
@NeverClassInline
public static class A extends Parent {
@@ -95,13 +90,8 @@
}
public static class Main {
- @NeverInline
- public static void parent(Parent p) {
- p.foo();
- }
-
public static void main(String[] args) {
- parent(new A());
+ new A();
new B();
}
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
index 1f0e3e6..04bb9d7 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
@@ -12,6 +12,7 @@
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.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class ClassesWithNativeMethodsTest extends HorizontalClassMergingTestBase {
@@ -31,7 +32,8 @@
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspector(inspector -> inspector.assertNoClassesMerged())
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertFailureWithErrorThatMatches(
allOf(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
index 935e75e..369ebfd 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
@@ -50,7 +50,6 @@
}
}
- @NoHorizontalClassMerging
@NeverClassInline
public static class B extends A {}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
index adabb3e..63c1f18 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
@@ -4,16 +4,18 @@
package com.android.tools.r8.classmerging.horizontal;
-import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.codeinspector.VerticallyMergedClassesInspector;
import java.util.Set;
import java.util.stream.Collectors;
+import org.junit.Ignore;
import org.junit.Test;
public class JavaLambdaMergingTest extends HorizontalClassMergingTestBase {
@@ -23,6 +25,7 @@
}
@Test
+ @Ignore("b/174809311): Test does not work with hygienic lambdas. Rewrite or remove")
public void test() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
@@ -38,16 +41,12 @@
inspector -> {
Set<DexType> lambdaSources =
inspector.getSources().stream()
- .filter(x -> x.toSourceString().contains(LAMBDA_CLASS_NAME_PREFIX))
+ .filter(JavaLambdaMergingTest::isLambda)
.collect(Collectors.toSet());
assertEquals(3, lambdaSources.size());
DexType firstTarget = inspector.getTarget(lambdaSources.iterator().next());
for (DexType lambdaSource : lambdaSources) {
- assertTrue(
- inspector
- .getTarget(lambdaSource)
- .toSourceString()
- .contains(LAMBDA_CLASS_NAME_PREFIX));
+ assertTrue(isLambda(inspector.getTarget(lambdaSource)));
assertEquals(firstTarget, inspector.getTarget(lambdaSource));
}
})
@@ -59,6 +58,11 @@
.assertSuccessWithOutputLines("Hello world!");
}
+ private static boolean isLambda(DexType type) {
+ return SyntheticItemsTestUtils.isExternalLambda(
+ Reference.classFromDescriptor(type.toDescriptorString()));
+ }
+
public static class Main {
public static void main(String[] args) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
index 34972f6..13cc54f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
@@ -59,7 +59,6 @@
});
}
- @NoVerticalClassMerging
public static class Parent {
@NeverInline
public void foo() {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
index 671f740..ce0425e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
@@ -35,6 +35,7 @@
}
})
.enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
index 366800a..eba6de8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
@@ -25,6 +25,7 @@
.addOptionsModification(
options ->
options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
+ .enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
index c8ad21d..47994ef 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
@@ -25,6 +25,7 @@
.addOptionsModification(
options ->
options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
+ .enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
index e456600..635ec43 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.classmerging.horizontal.HorizontalClassMergingTestBase;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class OverrideAbstractMethodWithDefaultTest extends HorizontalClassMergingTestBase {
@@ -31,7 +32,7 @@
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertNoClassesMerged())
+ enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("J", "B2")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
index 526aa00..9a727f5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.classmerging.horizontal.HorizontalClassMergingTestBase;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class OverrideMergeAbsentTest extends HorizontalClassMergingTestBase {
@@ -32,7 +33,7 @@
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertNoClassesMerged())
+ enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A", "B", "A", "J")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/NoIllegalClassAccessWithAccessModificationsTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/NoIllegalClassAccessWithAccessModificationsTest.java
index 35e27eb..f2edbce 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/NoIllegalClassAccessWithAccessModificationsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/NoIllegalClassAccessWithAccessModificationsTest.java
@@ -42,6 +42,7 @@
.addKeepMainRule(TestClass.class)
.addVerticallyMergedClassesInspector(this::inspectVerticallyMergedClasses)
.allowAccessModification()
+ .enableInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/NonReboundFieldAccessOnMergedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/NonReboundFieldAccessOnMergedClassTest.java
index 0f28809..c65809a 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/NonReboundFieldAccessOnMergedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/NonReboundFieldAccessOnMergedClassTest.java
@@ -37,6 +37,7 @@
.addVerticallyMergedClassesInspector(
inspector -> inspector.assertMergedIntoSubtype(C.class))
.enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), Main.class)
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 8dc4e01..5468cae 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
@@ -39,7 +39,6 @@
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.io.File;
@@ -336,7 +335,8 @@
CF_DIR.resolve("ConflictingInterfaceSignaturesTest.class"),
CF_DIR.resolve("ConflictingInterfaceSignaturesTest$A.class"),
CF_DIR.resolve("ConflictingInterfaceSignaturesTest$B.class"),
- CF_DIR.resolve("ConflictingInterfaceSignaturesTest$InterfaceImpl.class")
+ CF_DIR.resolve("ConflictingInterfaceSignaturesTest$InterfaceImpl.class"),
+ CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -361,7 +361,8 @@
JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest.class"),
JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$A.class"),
JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$B.class"),
- JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$C.class")
+ JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$C.class"),
+ JAVA8_CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -384,7 +385,8 @@
new Path[] {
JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest.class"),
JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$A.class"),
- JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$B.class")
+ JAVA8_CF_DIR.resolve("NestedDefaultInterfaceMethodsTest$B.class"),
+ JAVA8_CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -461,8 +463,14 @@
new Path[] {
CF_DIR.resolve("ProguardFieldMapTest.class"),
CF_DIR.resolve("ProguardFieldMapTest$A.class"),
- CF_DIR.resolve("ProguardFieldMapTest$B.class")
+ CF_DIR.resolve("ProguardFieldMapTest$B.class"),
+ CF_DIR.resolve("NeverClassInline.class")
};
+ Set<String> preservedClassNamesWithoutClassMerging =
+ ImmutableSet.of(
+ "classmerging.ProguardFieldMapTest",
+ "classmerging.ProguardFieldMapTest$A",
+ "classmerging.ProguardFieldMapTest$B");
// Try without vertical class merging, to check that output is as expected.
R8TestCompileResult compileResultWithoutClassMerging =
@@ -478,7 +486,7 @@
.allowUnusedProguardConfigurationRules(),
main,
readProgramFiles(programFiles),
- Predicates.alwaysTrue());
+ preservedClassNamesWithoutClassMerging::contains);
ClassNameMapper mappingWithoutClassMerging =
ClassNameMapper.mapperFromString(compileResultWithoutClassMerging.getProguardMap());
@@ -528,8 +536,14 @@
new Path[] {
CF_DIR.resolve("ProguardMethodMapTest.class"),
CF_DIR.resolve("ProguardMethodMapTest$A.class"),
- CF_DIR.resolve("ProguardMethodMapTest$B.class")
+ CF_DIR.resolve("ProguardMethodMapTest$B.class"),
+ CF_DIR.resolve("NeverClassInline.class")
};
+ Set<String> preservedClassNamesWithoutClassMerging =
+ ImmutableSet.of(
+ "classmerging.ProguardMethodMapTest",
+ "classmerging.ProguardMethodMapTest$A",
+ "classmerging.ProguardMethodMapTest$B");
// Try without vertical class merging, to check that output is as expected.
R8TestCompileResult compileResultWithoutClassMerging =
@@ -545,7 +559,7 @@
.allowUnusedProguardConfigurationRules(),
main,
readProgramFiles(programFiles),
- Predicates.alwaysTrue());
+ preservedClassNamesWithoutClassMerging::contains);
ClassNameMapper mappingWithoutClassMerging =
ClassNameMapper.mapperFromString(compileResultWithoutClassMerging.getProguardMap());
@@ -603,8 +617,14 @@
new Path[] {
CF_DIR.resolve("ProguardMethodMapTest.class"),
CF_DIR.resolve("ProguardMethodMapTest$A.class"),
- CF_DIR.resolve("ProguardMethodMapTest$B.class")
+ CF_DIR.resolve("ProguardMethodMapTest$B.class"),
+ CF_DIR.resolve("NeverClassInline.class")
};
+ Set<String> preservedClassNamesWithoutClassMerging =
+ ImmutableSet.of(
+ "classmerging.ProguardMethodMapTest",
+ "classmerging.ProguardMethodMapTest$A",
+ "classmerging.ProguardMethodMapTest$B");
// Try without vertical class merging, to check that output is as expected.
R8TestCompileResult compileResultWithoutClassMerging =
@@ -624,7 +644,7 @@
.allowUnusedProguardConfigurationRules(),
main,
readProgramFiles(programFiles),
- Predicates.alwaysTrue());
+ preservedClassNamesWithoutClassMerging::contains);
ClassNameMapper mappingWithoutClassMerging =
ClassNameMapper.mapperFromString(compileResultWithoutClassMerging.getProguardMap());
@@ -690,7 +710,8 @@
new Path[] {
CF_DIR.resolve("SubClassThatReferencesSuperMethod.class"),
CF_DIR.resolve("SuperClassWithReferencedMethod.class"),
- CF_DIR.resolve("SuperCallRewritingTest.class")
+ CF_DIR.resolve("SuperCallRewritingTest.class"),
+ CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -721,7 +742,8 @@
Path[] programFiles =
new Path[] {
CF_DIR.resolve("SuperClassWithReferencedMethod.class"),
- CF_DIR.resolve("SuperCallRewritingTest.class")
+ CF_DIR.resolve("SuperCallRewritingTest.class"),
+ CF_DIR.resolve("NeverInline.class")
};
// Build SubClassThatReferencesMethod.
@@ -936,7 +958,8 @@
CF_DIR.resolve("ConflictingInterfaceSignaturesTest.class"),
CF_DIR.resolve("ConflictingInterfaceSignaturesTest$A.class"),
CF_DIR.resolve("ConflictingInterfaceSignaturesTest$B.class"),
- CF_DIR.resolve("ConflictingInterfaceSignaturesTest$InterfaceImpl.class")
+ CF_DIR.resolve("ConflictingInterfaceSignaturesTest$InterfaceImpl.class"),
+ CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -958,7 +981,8 @@
new Path[] {
JAVA8_CF_DIR.resolve("MergeDefaultMethodIntoClassTest.class"),
JAVA8_CF_DIR.resolve("MergeDefaultMethodIntoClassTest$A.class"),
- JAVA8_CF_DIR.resolve("MergeDefaultMethodIntoClassTest$B.class")
+ JAVA8_CF_DIR.resolve("MergeDefaultMethodIntoClassTest$B.class"),
+ JAVA8_CF_DIR.resolve("NeverInline.class")
};
ImmutableSet<String> preservedClassNames =
ImmutableSet.of(
@@ -1021,17 +1045,21 @@
Path[] programFiles =
new Path[] {
CF_DIR.resolve("SimpleInterfaceAccessTest.class"),
+ CF_DIR.resolve("SimpleInterfaceAccessTest$1.class"),
CF_DIR.resolve("SimpleInterfaceAccessTest$SimpleInterface.class"),
CF_DIR.resolve("SimpleInterfaceAccessTest$OtherSimpleInterface.class"),
CF_DIR.resolve("SimpleInterfaceAccessTest$OtherSimpleInterfaceImpl.class"),
CF_DIR.resolve("pkg/SimpleInterfaceImplRetriever.class"),
- CF_DIR.resolve("pkg/SimpleInterfaceImplRetriever$SimpleInterfaceImpl.class")
+ CF_DIR.resolve("pkg/SimpleInterfaceImplRetriever$SimpleInterfaceImpl.class"),
+ CF_DIR.resolve("pkg/SimpleInterfaceImplRetriever$1.class"),
+ CF_DIR.resolve("NeverInline.class")
};
// SimpleInterface cannot be merged into SimpleInterfaceImpl because SimpleInterfaceImpl
// is in a different package and is not public.
ImmutableSet<String> preservedClassNames =
ImmutableSet.of(
"classmerging.SimpleInterfaceAccessTest",
+ "classmerging.SimpleInterfaceAccessTest$1",
"classmerging.SimpleInterfaceAccessTest$SimpleInterface",
"classmerging.SimpleInterfaceAccessTest$OtherSimpleInterface",
"classmerging.SimpleInterfaceAccessTest$OtherSimpleInterfaceImpl",
@@ -1081,8 +1109,10 @@
Path[] programFiles =
new Path[] {
CF_DIR.resolve("TemplateMethodTest.class"),
+ CF_DIR.resolve("TemplateMethodTest$1.class"),
CF_DIR.resolve("TemplateMethodTest$AbstractClass.class"),
- CF_DIR.resolve("TemplateMethodTest$AbstractClassImpl.class")
+ CF_DIR.resolve("TemplateMethodTest$AbstractClassImpl.class"),
+ CF_DIR.resolve("NeverInline.class")
};
Set<String> preservedClassNames =
ImmutableSet.of(
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index 13d59dc..a5a1a8a 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.ClassAccessFlags;
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.naming.ClassNamingForNameMapper;
import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange;
@@ -2161,8 +2162,28 @@
}
private static boolean isInLambdaClass(VmMirror mirror, Location location) {
- String classSig = mirror.getClassSignature(location.classID);
- return classSig.contains("$$Lambda$");
+ // TODO(b/174809573): These "lambda" specific methods are highly questionable.
+ // Determine the exact filtering behavior of intellij (which is very likely not name
+ // based) and update this filter accordingly.
+ CommandPacket cmd =
+ new CommandPacket(
+ ReferenceTypeCommandSet.CommandSetID, ReferenceTypeCommandSet.ModifiersCommand);
+ cmd.setNextValueAsReferenceTypeID(location.classID);
+ ReplyPacket reply = mirror.performCommand(cmd);
+ mirror.checkReply(reply);
+ int modifiers = reply.getNextValueAsInt();
+ ClassAccessFlags flags = ClassAccessFlags.fromCfAccessFlags(modifiers);
+ if (!flags.isSynthetic()) {
+ return false;
+ }
+ String signature = mirror.getClassSignature(location.classID);
+ if (signature.contains("-CC")) {
+ // TODO(b/174809573): The need to return false here indicates a questionable test
+ // expectation. Either the test is incorrect or there is a bug in our generation of
+ // -CC classes marked as synthetic as that would lead to unwanted debugger filtering.
+ return false;
+ }
+ return true;
}
private static boolean isLambdaMethod(VmMirror mirror, Location location) {
diff --git a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
index deb97d8..ff841d7 100644
--- a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
@@ -54,6 +54,7 @@
.noMinification()
.noTreeShaking()
.addKeepAllAttributes()
+ .addDontWarnJetBrainsAnnotations()
.setMode(CompilationMode.DEBUG)
.setMinApi(parameters.getApiLevel())
.compileWithExpectedDiagnostics(TestDiagnosticMessages::assertNoMessages);
diff --git a/src/test/java/com/android/tools/r8/debug/LocalsTest.java b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
index 7eeed7d..68b67a9 100644
--- a/src/test/java/com/android/tools/r8/debug/LocalsTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
@@ -285,41 +285,46 @@
"Locals",
breakpoint("Locals", "breakpoint"),
run(),
- inspect(state -> {
- // 1st breakpoint: all lengthOfArray[N] are set to 0
- FrameInspector outerFrame = state.getFrame(1);
+ inspect(
+ state -> {
+ // 1st breakpoint: all lengthOfArray[N] are set to 0
+ FrameInspector outerFrame = state.getFrame(1);
- Map<String, Value> localValues = outerFrame.getLocalValues();
+ Map<String, Value> localValues = outerFrame.getLocalValues();
- for (int i = minIndex; i <= maxIndex; ++i) {
- String varName = "lengthOfArray" + i;
- Assert.assertTrue(localValues.containsKey(varName));
- Assert.assertEquals(Value.createInt(0), localValues.get(varName));
- }
+ for (int i = minIndex; i <= maxIndex; ++i) {
+ String varName = "lengthOfArray" + i;
+ Assert.assertTrue(localValues.containsKey(varName));
+ Assert.assertEquals(Value.createInt(0), localValues.get(varName));
+ }
- // Capture IDs of arrays.
- for (int i = minIndex; i <= maxIndex; ++i) {
- String varName = "array" + i;
- Assert.assertTrue(localValues.containsKey(varName));
- arrayLocals.put(varName, localValues.get(varName));
- }
- }),
+ // Capture IDs of arrays.
+ for (int i = minIndex; i <= maxIndex; ++i) {
+ String varName = "array" + i;
+ Assert.assertTrue(localValues.containsKey(varName));
+ arrayLocals.put(varName, localValues.get(varName));
+ }
+ }),
// Step out to reach next instructions in the tested method
stepOut(),
- inspect(state -> {
- Assert.assertEquals("Locals.java", state.getSourceFile());
- Assert.assertEquals(107, state.getLineNumber());
- // Verify that all arrays have the same value.
- arrayLocals.forEach((name, value) -> state.checkLocal(name, value));
- }),
+ inspect(
+ state -> {
+ Assert.assertEquals("Locals.java", state.getSourceFile());
+ Assert.assertEquals(107, state.getLineNumber());
+ // Verify that all arrays have the same value.
+ arrayLocals.forEach(state::checkLocal);
+ }),
// Step instruction by instruction to ensure all locals previously declared are safe.
- stepUntil(StepKind.OVER, StepLevel.INSTRUCTION, state -> {
- final String sourceFile = state.getSourceFile();
- final int lineNumber = state.getLineNumber();
- arrayLocals.forEach((name, value) -> state.checkLocal(name, value));
- // Stop when we reach the expected line.
- return lineNumber == 125 && sourceFile.equals("Locals.java");
- }),
+ stepUntil(
+ StepKind.OVER,
+ StepLevel.INSTRUCTION,
+ state -> {
+ final String sourceFile = state.getSourceFile();
+ final int lineNumber = state.getLineNumber();
+ arrayLocals.forEach(state::checkLocal);
+ // Stop when we reach the expected line.
+ return lineNumber == 125 && sourceFile.equals("Locals.java");
+ }),
run());
}
diff --git a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
index 0c9c4b1..208c2cb 100644
--- a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
+++ b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
@@ -28,8 +28,8 @@
public static Collection<Object[]> setup() {
DelayedDebugTestConfig cf =
temp -> new CfDebugTestConfig().addPaths(DebugTestBase.DEBUGGEE_JAR);
- DelayedDebugTestConfig r8cf = temp -> new R8CfDebugTestResourcesConfig(temp);
- DelayedDebugTestConfig d8 = temp -> new D8DebugTestResourcesConfig(temp);
+ DelayedDebugTestConfig r8cf = R8CfDebugTestResourcesConfig::new;
+ DelayedDebugTestConfig d8 = D8DebugTestResourcesConfig::new;
return ImmutableList.of(
new Object[] {"CF", cf},
new Object[] {"D8", d8},
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java b/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
index 8f304c6..875ead2 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarMissingTypeLambdaTest.java
@@ -3,8 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@ -19,6 +17,7 @@
import com.android.tools.r8.errors.InterfaceDesugarMissingTypeDiagnostic;
import com.android.tools.r8.position.Position;
import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import org.junit.Test;
@@ -79,7 +78,7 @@
assertEquals(
Reference.classFromClass(MissingInterface.class), desugarWarning.getMissingType());
// TODO(b/132671303): The context class should not be the synthesized lambda class.
- assertThat(desugarWarning.getContextType().getDescriptor(), containsString("$$Lambda"));
+ assertTrue(SyntheticItemsTestUtils.isInternalLambda(desugarWarning.getContextType()));
// TODO(b/132671303): The position info should be the method context.
assertEquals(Position.UNKNOWN, desugarWarning.getPosition());
}
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
index c9377fe..a0b196f 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFile.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import java.nio.file.Path;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -47,8 +48,7 @@
private void checkHasLambdaClass(CodeInspector inspector) {
assertTrue(
- inspector.allClasses().stream()
- .anyMatch(subject -> subject.getOriginalName().contains("-$$Lambda$")));
+ inspector.allClasses().stream().anyMatch(FoundClassSubject::isSynthesizedJavaLambdaClass));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java
index f63c4d9..93e46d0 100644
--- a/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java
@@ -106,7 +106,6 @@
}
}
- @FunctionalInterface
public interface CharConsumer extends Consumer<Character>, IntConsumer {
void accept(char c);
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
index d094c78..acfc021 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
@@ -3,9 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar.backports;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
@@ -16,10 +13,10 @@
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.desugar.backports.AbstractBackportTest.MiniAssert;
import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.google.common.collect.ImmutableList;
@@ -200,9 +197,7 @@
private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
inspector.forAllClasses(
clazz -> {
- assertThat(
- clazz.getFinalName(),
- not(containsString(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)));
+ SyntheticNaming.verifyNotInternalSynthetic(clazz.getFinalReference());
if (!clazz.getOriginalName().equals(MiniAssert.class.getTypeName())) {
clazz.forAllMethods(
method ->
@@ -233,11 +228,11 @@
// of intermediates.
Set<MethodReference> expectedSynthetics =
ImmutableSet.of(
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User1.class, 0, Character.class.getMethod("compare", char.class, char.class)),
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User1.class, 1, Boolean.class.getMethod("compare", boolean.class, boolean.class)),
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User2.class, 0, Integer.class.getMethod("compare", int.class, int.class)));
assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
index 45f8957..05f84af 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar.backports;
-import static com.android.tools.r8.synthesis.SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -25,11 +24,11 @@
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.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
@@ -57,11 +56,6 @@
static final List<Class<?>> MAIN_DEX_LIST_CLASSES =
ImmutableList.of(MiniAssert.class, TestClass.class, User2.class);
- static final String SyntheticUnderUser1 =
- User1.class.getTypeName() + EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
- static final String SyntheticUnderUser2 =
- User2.class.getTypeName() + EXTERNAL_SYNTHETIC_CLASS_SEPARATOR;
-
private final TestParameters parameters;
@Parameterized.Parameters(name = "{0}")
@@ -341,16 +335,16 @@
private ImmutableSet<MethodReference> getNonMainDexExpectedSynthetics()
throws NoSuchMethodException {
return ImmutableSet.of(
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User1.class, 1, Boolean.class.getMethod("compare", boolean.class, boolean.class)));
}
private ImmutableSet<MethodReference> getMainDexExpectedSynthetics()
throws NoSuchMethodException {
return ImmutableSet.of(
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User1.class, 0, Character.class.getMethod("compare", char.class, char.class)),
- SyntheticItemsTestUtils.syntheticMethod(
+ SyntheticItemsTestUtils.syntheticBackportMethod(
User2.class, 0, Integer.class.getMethod("compare", int.class, int.class)));
}
diff --git a/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java b/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
index 2dbcc30..fdb1044 100644
--- a/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/bridge/LambdaReturnTypeBridgeTest.java
@@ -62,12 +62,7 @@
codeInspector -> {
boolean foundBridge = false;
for (FoundClassSubject clazz : codeInspector.allClasses()) {
- if (clazz
- .getOriginalName()
- .contains(
- "-$$Lambda$"
- + LambdaWithMultipleImplementingInterfaces.class.getSimpleName()
- + "$")) {
+ if (clazz.isSynthesizedJavaLambdaClass()) {
// Find bridge method and check whether or not it has a cast.
for (FoundMethodSubject bridge : clazz.allMethods(FoundMethodSubject::isBridge)) {
foundBridge = true;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
index f71c916..2494871 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
@@ -174,6 +174,11 @@
configurationAlternative3(options, false, parameters))
.addInnerClasses(BufferedReaderTest.class)
.addKeepMainRule(TestClass.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder ->
+ builder.addDontWarnRetargetLibraryMember(
+ "virtualDispatch$BufferedReader$lines$dispatchHolder"))
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
index cf0d8ef..33d3f35 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.desugar.desugaredlibrary;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -15,7 +16,6 @@
import java.util.List;
import java.util.ListIterator;
import java.util.Spliterator;
-import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -64,6 +64,9 @@
.addKeepMainRule(Executor.class)
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
.compile()
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibrary,
@@ -115,21 +118,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return null;
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return null;
}
@@ -144,27 +144,27 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean addAll(int index, @NotNull Collection<? extends E> c) {
+ public boolean addAll(int index, Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
@@ -199,19 +199,16 @@
return 0;
}
- @NotNull
@Override
public ListIterator<E> listIterator() {
return null;
}
- @NotNull
@Override
public ListIterator<E> listIterator(int index) {
return null;
}
- @NotNull
@Override
public List<E> subList(int fromIndex, int toIndex) {
return null;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
index 4bd591e..7206b75 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
@@ -15,7 +15,6 @@
import java.util.Iterator;
import java.util.List;
import java.util.function.Predicate;
-import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -82,6 +81,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(CustomCollectionInterfaceSuperTest.class)
.addKeepMainRule(Main.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder ->
+ builder
+ .addDontWarnEmulatedLibraryClass(Collection.class)
+ .addDontWarnVivifiedClass(Predicate.class))
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
@@ -153,21 +158,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -182,22 +184,22 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
@@ -226,21 +228,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -255,22 +254,22 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
@@ -299,21 +298,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -328,22 +324,22 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
index 0707ab9..ce35ef0 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
@@ -9,6 +9,8 @@
import com.android.tools.r8.D8TestRunResult;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import java.nio.file.Path;
import java.util.ArrayList;
@@ -106,6 +108,9 @@
testForR8(parameters.getBackend())
.addInnerClasses(CustomCollectionSuperCallsTest.class)
.addKeepMainRule(Executor.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ TestShrinkerBuilder::addDontWarnVivifiedClasses)
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
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 0947a55..9212761 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
@@ -24,8 +24,6 @@
import java.util.List;
import java.util.SortedSet;
import java.util.stream.Stream;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -97,10 +95,7 @@
.disableDesugaring()
.compile()
.assertNoMessages()
- .inspect(
- inspector -> {
- this.assertCustomCollectionCallsCorrect(inspector);
- })
+ .inspect(this::assertCustomCollectionCallsCorrect)
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibrary,
parameters.getApiLevel(),
@@ -138,6 +133,9 @@
.addInnerClasses(CustomCollectionTest.class)
.setMinApi(parameters.getApiLevel())
.addKeepClassAndMembersRules(Executor.class)
+ .applyIf(
+ requiresEmulatedInterfaceCoreLibDesugaring(parameters),
+ builder -> builder.addDontWarnEmulatedLibraryClasses().addDontWarnVivifiedClasses())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
.inspect(this::assertCustomCollectionCallsCorrect)
@@ -161,7 +159,8 @@
.allMatch(
instr ->
instr.toString().contains("$-EL")
- || instr.toString().contains("Comparator$-CC")));
+ || instr.toString().contains("Comparator$-CC")
+ || instr.toString().contains("Stream$-CC")));
} else {
assertTrue(direct.streamInstructions().noneMatch(instr -> instr.toString().contains("$-EL")));
}
@@ -178,7 +177,8 @@
.allMatch(
instr ->
instr.toString().contains("$-EL")
- || instr.toString().contains("Comparator$-CC")));
+ || instr.toString().contains("Comparator$-CC")
+ || instr.toString().contains("Stream$-CC")));
inherited.streamInstructions().forEach(this::assertInheritedDispatchCorrect);
}
@@ -311,21 +311,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -340,22 +337,22 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
@@ -369,25 +366,21 @@
// Implements directly a core library interface which implements other library interfaces.
static class CustomSortedSet<E> implements SortedSet<E> {
- @Nullable
@Override
public Comparator<? super E> comparator() {
return null;
}
- @NotNull
@Override
public SortedSet<E> subSet(E fromElement, E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> headSet(E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> tailSet(E fromElement) {
return new CustomSortedSet<>();
@@ -418,21 +411,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -447,7 +437,7 @@
}
@Override
- public boolean addAll(@NotNull Collection c) {
+ public boolean addAll(Collection c) {
return false;
}
@@ -455,17 +445,17 @@
public void clear() {}
@Override
- public boolean removeAll(@NotNull Collection c) {
+ public boolean removeAll(Collection c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection c) {
+ public boolean retainAll(Collection c) {
return false;
}
@Override
- public boolean containsAll(@NotNull Collection c) {
+ public boolean containsAll(Collection c) {
return false;
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
index f7b5e5d..9623e7c 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryDeterminismTest.java
@@ -17,11 +17,16 @@
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Sets.SetView;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -53,12 +58,33 @@
private void assertIdenticalInspectors(Path libDexFile1, Path libDexFile2) throws IOException {
CodeInspector i1 = new CodeInspector(libDexFile1.resolve("classes.dex"));
CodeInspector i2 = new CodeInspector(libDexFile2.resolve("classes.dex"));
+ assertIdenticalInspectors(i1, i2);
+ }
+
+ public static void assertIdenticalInspectors(CodeInspector i1, CodeInspector i2) {
assertEquals(i1.allClasses().size(), i2.allClasses().size());
Map<DexEncodedMethod, DexEncodedMethod> diffs = new IdentityHashMap<>();
for (FoundClassSubject clazz1 : i1.allClasses()) {
ClassSubject clazz = i2.clazz(clazz1.getOriginalName());
assertTrue(clazz.isPresent());
FoundClassSubject clazz2 = clazz.asFoundClassSubject();
+ Set<String> methods1 =
+ clazz1.allMethods().stream()
+ .map(FoundMethodSubject::toString)
+ .collect(Collectors.toSet());
+ Set<String> methods2 =
+ clazz2.allMethods().stream()
+ .map(FoundMethodSubject::toString)
+ .collect(Collectors.toSet());
+ SetView<String> union = Sets.union(methods1, methods2);
+ assertEquals(
+ "Inspector 1 contains more methods",
+ Collections.emptySet(),
+ Sets.difference(union, methods1));
+ assertEquals(
+ "Inspector 2 contains more methods",
+ Collections.emptySet(),
+ Sets.difference(union, methods2));
assertEquals(clazz1.allMethods().size(), clazz2.allMethods().size());
for (FoundMethodSubject method1 : clazz1.allMethods()) {
MethodSubject method = clazz2.method(method1.asMethodReference());
@@ -79,7 +105,7 @@
assertTrue(printDiffs(diffs), diffs.isEmpty());
}
- private String printDiffs(Map<DexEncodedMethod, DexEncodedMethod> diffs) {
+ private static String printDiffs(Map<DexEncodedMethod, DexEncodedMethod> diffs) {
StringBuilder sb = new StringBuilder();
sb.append("The following methods had differences from one dex file to the other (")
.append(diffs.size())
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index 5b87397..8a9fc12 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -24,7 +24,7 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
import com.android.tools.r8.ir.desugar.DesugaredLibraryConfigurationParser;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring;
+import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.tracereferences.TraceReferences;
import com.android.tools.r8.utils.AndroidApiLevel;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
index d4f08fc..9447057 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ArtCommandBuilder;
import com.android.tools.r8.ToolHelper.ProcessResult;
@@ -247,6 +248,9 @@
SplitterTestBase.simpleSplitProvider(
builder, feature2Path, temp, FeatureClass2.class))
.addKeepAllClassesRule()
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
.writeToZip(basePath);
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
index f998b89..0c16701 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
@@ -19,7 +19,6 @@
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
-import org.jetbrains.annotations.NotNull;
import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -138,7 +137,6 @@
this.collection = collection;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return collection.iterator();
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 31bbcbd..ff7577f 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
@@ -14,6 +14,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestCompileResult;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
@@ -264,6 +265,9 @@
testForR8(parameters.getBackend())
.addInnerClasses(JavaTimeTest.class)
.addKeepMainRule(TestClass.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ TestShrinkerBuilder::addDontWarnRetargetLibraryMembers)
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
index 616ec2c..6c443af 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
@@ -6,13 +6,13 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.function.Predicate;
-import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -46,6 +46,9 @@
testForR8(parameters.getBackend())
.addInnerClasses(MinimalInterfaceSuperTest.class)
.addKeepMainRule(Main.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder -> builder.addDontWarnVivifiedClass(Predicate.class))
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel())
.compile()
@@ -71,7 +74,6 @@
}
static class Col1<E> extends AbstractCollection<E> implements Col1Itf<E> {
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
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 a6ea994..f0e55c0 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
@@ -16,8 +16,6 @@
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -97,25 +95,21 @@
// Implements directly a core library interface which implements other library interfaces.
static class CustomSortedSet<E> implements SortedSet<E> {
- @Nullable
@Override
public Comparator<? super E> comparator() {
return null;
}
- @NotNull
@Override
public SortedSet<E> subSet(E fromElement, E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> headSet(E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> tailSet(E fromElement) {
return new CustomSortedSet<>();
@@ -146,21 +140,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -175,7 +166,7 @@
}
@Override
- public boolean addAll(@NotNull Collection c) {
+ public boolean addAll(Collection c) {
return false;
}
@@ -183,17 +174,17 @@
public void clear() {}
@Override
- public boolean removeAll(@NotNull Collection c) {
+ public boolean removeAll(Collection c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection c) {
+ public boolean retainAll(Collection c) {
return false;
}
@Override
- public boolean containsAll(@NotNull Collection c) {
+ public boolean containsAll(Collection c) {
return false;
}
}
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 98ad7dc..da41454 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
@@ -7,6 +7,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.util.ArrayList;
@@ -17,8 +18,6 @@
import java.util.List;
import java.util.Objects;
import java.util.SortedSet;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -67,6 +66,9 @@
.setMinApi(parameters.getApiLevel())
.addKeepClassAndMembersRules(Executor.class)
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder -> builder.addDontWarnEmulatedLibraryClass(Collection.class))
.compile()
.inspect(this::assertNoForwardingStreamMethod)
.addDesugaredCoreLibraryRunClassPath(
@@ -103,25 +105,21 @@
// Implements directly a core library interface which implements other library interfaces.
static class CustomSortedSet<E> implements SortedSet<E> {
- @Nullable
@Override
public Comparator<? super E> comparator() {
return null;
}
- @NotNull
@Override
public SortedSet<E> subSet(E fromElement, E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> headSet(E toElement) {
return new CustomSortedSet<>();
}
- @NotNull
@Override
public SortedSet<E> tailSet(E fromElement) {
return new CustomSortedSet<>();
@@ -152,21 +150,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return a;
}
@@ -181,7 +176,7 @@
}
@Override
- public boolean addAll(@NotNull Collection c) {
+ public boolean addAll(Collection c) {
return false;
}
@@ -189,17 +184,17 @@
public void clear() {}
@Override
- public boolean removeAll(@NotNull Collection c) {
+ public boolean removeAll(Collection c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection c) {
+ public boolean retainAll(Collection c) {
return false;
}
@Override
- public boolean containsAll(@NotNull Collection c) {
+ public boolean containsAll(Collection c) {
return false;
}
}
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 8031f43..f62067c 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
@@ -421,8 +421,8 @@
private String expectedOutput(boolean objectsRequireNonNullWithSupplierSupported) {
return StringUtils.lines(
"1",
- "true",
- "true",
+ "false",
+ "false",
Objects.toString(Objects.hash(1, 2)),
"4",
"NPE",
@@ -525,8 +525,8 @@
boolean objectsRequireNonNullWithSupplierSupported = Boolean.parseBoolean(args[0]);
// Android K methods.
objectsCompare("b", "a");
- objectsDeepEquals(args, args);
- objectsEquals(args, args);
+ objectsDeepEquals(args, new Object());
+ objectsEquals(args, new Object());
objectsHash(1, 2);
objectsHashCode(4);
objectsRequireNonNull(System.currentTimeMillis() >= 0 ? null : new Object());
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 69f366f..07f4415 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
@@ -14,6 +14,7 @@
import com.android.tools.r8.D8TestRunResult;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.utils.AndroidApiLevel;
@@ -120,6 +121,9 @@
testForR8(parameters.getBackend())
.minification(minifying)
.addKeepMainRule(TEST_CLASS)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
.addProgramFiles(Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR + "stream.jar"))
.setMinApi(parameters.getApiLevel())
.addOptionsModification(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
index 59dbd1b..3eb81ed 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.desugar.desugaredlibrary;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import java.time.Instant;
@@ -64,6 +63,13 @@
testForR8(Backend.DEX)
.addKeepMainRule(Executor.class)
.addInnerClasses(RetargetOverrideTest.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ builder ->
+ builder
+ .addDontWarnRetargetLibraryMembers()
+ .addDontWarnTimeConversions()
+ .addDontWarnVivifiedClasses())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
index 2ad9b4f..9496b9c4 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
@@ -6,7 +6,9 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import java.nio.file.Path;
@@ -79,6 +81,9 @@
testForR8(parameters.getBackend())
.addProgramFiles(INPUT_JAR)
.addKeepMainRule(MAIN_CLASS)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
index cb8c24f..42997cb 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
@@ -172,6 +172,9 @@
.setMinApi(parameters.getApiLevel())
.addProgramClasses(Impl.class)
.addLibraryClasses(CustomLibClass.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder -> builder.addDontWarnVivifiedClass(Consumer.class))
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
.inspect(this::assertLibraryOverridesThere)
@@ -189,6 +192,7 @@
.setMinApi(parameters.getApiLevel())
.addProgramClasses(Impl.class)
.addLibraryClasses(CustomLibClass.class)
+ .addDontWarnVivifiedClass(Consumer.class)
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
.inspect(this::assertLibraryOverridesThere)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
index 5c01507..1298096 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
@@ -23,7 +23,6 @@
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
-import org.jetbrains.annotations.NotNull;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -155,6 +154,10 @@
opt.desugaredLibraryConfiguration =
configurationWithSupportAllCallbacksFromLibrary(
opt, false, parameters, supportAllCallbacksFromLibrary))
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N)
+ && supportAllCallbacksFromLibrary,
+ builder -> builder.addDontWarnVivifiedClass(Consumer.class))
.compile()
.inspect(this::assertDoubleForEach)
.inspect(this::assertWrapperMethodsPresent)
@@ -224,15 +227,13 @@
return Collections.<E>singletonList(null).iterator();
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] a) {
+ public <T> T[] toArray(T[] a) {
return null;
}
@@ -247,22 +248,22 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> c) {
+ public boolean containsAll(Collection<?> c) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> c) {
+ public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> c) {
+ public boolean removeAll(Collection<?> c) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> c) {
+ public boolean retainAll(Collection<?> c) {
return false;
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
index b62045b..8fa7780 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
@@ -84,6 +84,9 @@
.addKeepMainRule(Executor.class)
.addProgramClasses(Executor.class, MyMap.class)
.addLibraryClasses(CustomLibClass.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
+ builder -> builder.addDontWarnVivifiedClass(BiConsumer.class))
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
.inspect(this::assertDupMethod)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
index 6afc3a5..24588c6 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
@@ -174,7 +174,7 @@
private Object1 field;
- private Object2(Object1 o) {
+ Object2(Object1 o) {
this.field = o;
}
}
@@ -183,7 +183,7 @@
private Object2 field;
- private Object3(Object2 o) {
+ Object3(Object2 o) {
this.field = o;
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
index 249f26f..0e66723 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import dalvik.system.PathClassLoader;
import java.sql.SQLDataException;
@@ -24,8 +25,6 @@
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -75,6 +74,11 @@
testForR8(Backend.DEX)
.addInnerClasses(GetGenericInterfaceTest.class)
.addKeepMainRule(Executor.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ builder ->
+ builder.addDontWarnRetargetLibraryMember(
+ "virtualDispatch$Date$toInstant$dispatchInterface"))
.noMinification()
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
@@ -301,7 +305,6 @@
return null;
}
- @Nullable
@Override
public V put(K k, V v) {
return null;
@@ -313,46 +316,43 @@
}
@Override
- public void putAll(@NotNull Map<? extends K, ? extends V> map) {}
+ public void putAll(Map<? extends K, ? extends V> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<K> keySet() {
return null;
}
- @NotNull
@Override
public Collection<V> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<K, V>> entrySet() {
return null;
}
@Override
- public V putIfAbsent(@NotNull K k, V v) {
+ public V putIfAbsent(K k, V v) {
return null;
}
@Override
- public boolean remove(@NotNull Object o, Object o1) {
+ public boolean remove(Object o, Object o1) {
return false;
}
@Override
- public boolean replace(@NotNull K k, @NotNull V v, @NotNull V v1) {
+ public boolean replace(K k, V v, V v1) {
return false;
}
@Override
- public V replace(@NotNull K k, @NotNull V v) {
+ public V replace(K k, V v) {
return null;
}
}
@@ -394,7 +394,6 @@
return null;
}
- @Nullable
@Override
public V put(K k, V v) {
return null;
@@ -406,46 +405,43 @@
}
@Override
- public void putAll(@NotNull Map<? extends K, ? extends V> map) {}
+ public void putAll(Map<? extends K, ? extends V> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<K> keySet() {
return null;
}
- @NotNull
@Override
public Collection<V> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<K, V>> entrySet() {
return null;
}
@Override
- public V putIfAbsent(@NotNull K k, V v) {
+ public V putIfAbsent(K k, V v) {
return null;
}
@Override
- public boolean remove(@NotNull Object o, Object o1) {
+ public boolean remove(Object o, Object o1) {
return false;
}
@Override
- public boolean replace(@NotNull K k, @NotNull V v, @NotNull V v1) {
+ public boolean replace(K k, V v, V v1) {
return false;
}
@Override
- public V replace(@NotNull K k, @NotNull V v) {
+ public V replace(K k, V v) {
return null;
}
@@ -475,21 +471,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return null;
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] ts) {
+ public <T> T[] toArray(T[] ts) {
return null;
}
@@ -504,27 +497,27 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> collection) {
+ public boolean containsAll(Collection<?> collection) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> collection) {
+ public boolean addAll(Collection<? extends E> collection) {
return false;
}
@Override
- public boolean addAll(int i, @NotNull Collection<? extends E> collection) {
+ public boolean addAll(int i, Collection<? extends E> collection) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> collection) {
+ public boolean removeAll(Collection<?> collection) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> collection) {
+ public boolean retainAll(Collection<?> collection) {
return false;
}
@@ -559,19 +552,16 @@
return 0;
}
- @NotNull
@Override
public ListIterator<E> listIterator() {
return null;
}
- @NotNull
@Override
public ListIterator<E> listIterator(int i) {
return null;
}
- @NotNull
@Override
public List<E> subList(int i, int i1) {
return null;
@@ -603,21 +593,18 @@
return false;
}
- @NotNull
@Override
public Iterator<E> iterator() {
return null;
}
- @NotNull
@Override
public Object[] toArray() {
return new Object[0];
}
- @NotNull
@Override
- public <T> T[] toArray(@NotNull T[] ts) {
+ public <T> T[] toArray(T[] ts) {
return null;
}
@@ -632,27 +619,27 @@
}
@Override
- public boolean containsAll(@NotNull Collection<?> collection) {
+ public boolean containsAll(Collection<?> collection) {
return false;
}
@Override
- public boolean addAll(@NotNull Collection<? extends E> collection) {
+ public boolean addAll(Collection<? extends E> collection) {
return false;
}
@Override
- public boolean addAll(int i, @NotNull Collection<? extends E> collection) {
+ public boolean addAll(int i, Collection<? extends E> collection) {
return false;
}
@Override
- public boolean removeAll(@NotNull Collection<?> collection) {
+ public boolean removeAll(Collection<?> collection) {
return false;
}
@Override
- public boolean retainAll(@NotNull Collection<?> collection) {
+ public boolean retainAll(Collection<?> collection) {
return false;
}
@@ -687,19 +674,16 @@
return 0;
}
- @NotNull
@Override
public ListIterator<E> listIterator() {
return null;
}
- @NotNull
@Override
public ListIterator<E> listIterator(int i) {
return null;
}
- @NotNull
@Override
public List<E> subList(int i, int i1) {
return null;
@@ -710,7 +694,6 @@
}
static class CollectionMapImplements2<R, C> implements Iterable<R>, Map<R, C> {
- @NotNull
@Override
public Iterator<R> iterator() {
return null;
@@ -741,7 +724,6 @@
return null;
}
- @Nullable
@Override
public C put(R r, C c) {
return null;
@@ -753,24 +735,21 @@
}
@Override
- public void putAll(@NotNull Map<? extends R, ? extends C> map) {}
+ public void putAll(Map<? extends R, ? extends C> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<R> keySet() {
return null;
}
- @NotNull
@Override
public Collection<C> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<R, C>> entrySet() {
return null;
@@ -778,7 +757,6 @@
}
static class CollectionMapExtendImplement<R, C> extends HashMap<R, C> implements Iterable<R> {
- @NotNull
@Override
public Iterator<R> iterator() {
return null;
@@ -809,7 +787,6 @@
return null;
}
- @Nullable
@Override
public C put(R r, C c) {
return null;
@@ -821,24 +798,21 @@
}
@Override
- public void putAll(@NotNull Map<? extends R, ? extends C> map) {}
+ public void putAll(Map<? extends R, ? extends C> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<R> keySet() {
return null;
}
- @NotNull
@Override
public Collection<C> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<R, C>> entrySet() {
return null;
@@ -847,7 +821,6 @@
static class CollectionMapImplements2Integer1<C>
implements Iterable<PathClassLoader>, Map<PathClassLoader, C> {
- @NotNull
@Override
public Iterator<PathClassLoader> iterator() {
return null;
@@ -878,7 +851,6 @@
return null;
}
- @Nullable
@Override
public C put(PathClassLoader unsafe, C c) {
return null;
@@ -890,24 +862,21 @@
}
@Override
- public void putAll(@NotNull Map<? extends PathClassLoader, ? extends C> map) {}
+ public void putAll(Map<? extends PathClassLoader, ? extends C> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<PathClassLoader> keySet() {
return null;
}
- @NotNull
@Override
public Collection<C> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<PathClassLoader, C>> entrySet() {
return null;
@@ -916,7 +885,6 @@
static class CollectionMapExtendImplementInteger1<C> extends HashMap<PathClassLoader, C>
implements Iterable<PathClassLoader> {
- @NotNull
@Override
public Iterator<PathClassLoader> iterator() {
return null;
@@ -924,7 +892,6 @@
}
static class CollectionMapImplements2Integer2<R> implements Iterable<R>, Map<R, PathClassLoader> {
- @NotNull
@Override
public Iterator<R> iterator() {
return null;
@@ -955,7 +922,6 @@
return null;
}
- @Nullable
@Override
public PathClassLoader put(R r, PathClassLoader unsafe) {
return null;
@@ -967,24 +933,21 @@
}
@Override
- public void putAll(@NotNull Map<? extends R, ? extends PathClassLoader> map) {}
+ public void putAll(Map<? extends R, ? extends PathClassLoader> map) {}
@Override
public void clear() {}
- @NotNull
@Override
public Set<R> keySet() {
return null;
}
- @NotNull
@Override
public Collection<PathClassLoader> values() {
return null;
}
- @NotNull
@Override
public Set<Entry<R, PathClassLoader>> entrySet() {
return null;
@@ -993,7 +956,6 @@
static class CollectionMapExtendImplementInteger2<R> extends HashMap<R, PathClassLoader>
implements Iterable<R> {
- @NotNull
@Override
public Iterator<R> iterator() {
return null;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonAllMapsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonAllMapsTest.java
index 45e6af7..d5a6637 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonAllMapsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonAllMapsTest.java
@@ -61,6 +61,7 @@
.addProgramFiles(GSON_2_8_1_JAR)
.addKeepMainRule(AllMapsTestClass.class)
.addKeepRuleFiles(GSON_CONFIGURATION)
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.allowDiagnosticMessages()
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonOptionalTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonOptionalTest.java
index d3fd68a..62cf8d2 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonOptionalTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GsonOptionalTest.java
@@ -56,6 +56,7 @@
.addProgramFiles(GSON_2_8_1_JAR)
.addKeepMainRule(OptionalTestClass.class)
.addKeepRuleFiles(GSON_CONFIGURATION)
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.addOptionsModification(opt -> opt.ignoreMissingClasses = true)
.allowDiagnosticMessages()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
index 8a07522..2c62b8f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
@@ -113,6 +113,7 @@
.addKeepMainRule(DIVMOD)
.addKeepMainRule(EXACTARITH)
.addProgramFiles(JDK_11_MATH_TEST_CLASS_FILES)
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), EXACTARITH)
.assertSuccessWithOutput("");
@@ -124,6 +125,7 @@
.addKeepMainRule(DIVMOD)
.addKeepMainRule(EXACTARITH)
.addProgramFiles(JDK_11_MATH_TEST_CLASS_FILES)
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), DIVMOD)
.assertSuccessWithOutput("");
@@ -134,6 +136,7 @@
testForR8(parameters.getBackend())
.addProgramFiles(JDK_11_STRICT_MATH_TEST_CLASS_FILES)
.addKeepMainRule(EXACTARITH)
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), EXACTARITH)
.assertSuccessWithOutput("");
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
index 394f36c..0901c28 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
@@ -287,14 +287,17 @@
D8TestRunResult result =
compileResult.run(
parameters.getRuntime(), "TestNGMainRunner", verbosity, runnableTests.get(path));
- if (result.getStdOut().contains("java.lang.NoSuchMethodError")
- && Arrays.stream(missingDesugaredMethods())
- .anyMatch(method -> result.getStdOut().contains(method))) {
+ String stdout = result.getStdOut();
+ if (stdout.contains("java.lang.NoSuchMethodError")
+ && Arrays.stream(missingDesugaredMethods()).anyMatch(stdout::contains)) {
// TODO(b/134732760): support Java 9 APIs.
- } else if (result.getStdOut().contains("in class Ljava/util/Random")
- && result.getStdOut().contains("java.lang.NoSuchMethodError")) {
+ } else if (stdout.contains("java.lang.NoSuchMethodError")
+ && stdout.contains("org.openjdk.tests.java.util.stream.IterateTest.testIterate")) {
+ // TODO(b/134732760): support Java 9 APIs.
+ } else if (stdout.contains("in class Ljava/util/Random")
+ && stdout.contains("java.lang.NoSuchMethodError")) {
// TODO(b/134732760): Random Java 9 Apis, support or do not use them.
- } else if (result.getStdOut().contains("java.lang.AssertionError")) {
+ } else if (stdout.contains("java.lang.AssertionError")) {
// TODO(b/134732760): Investigate and fix these issues.
} else {
String errorMessage = "STDOUT:\n" + result.getStdOut() + "STDERR:\n" + result.getStdErr();
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
index 89748a7..aa5393a 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
@@ -133,7 +133,8 @@
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.setMinApi(parameters.getApiLevel())
- .allowDiagnosticWarningMessages();
+ .allowDiagnosticWarningMessages()
+ .addDontWarnJetBrains();
KeepRuleConsumer keepRuleConsumer = null;
if (desugarLibrary) {
keepRuleConsumer = createKeepRuleConsumer(parameters);
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
index b61e9d8..bb66f2e 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
@@ -7,7 +7,11 @@
import static junit.framework.TestCase.assertEquals;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8;
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.R8Command.Builder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime;
@@ -16,10 +20,15 @@
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.cf.bootstrap.BootstrapCurrentEqualityTest;
import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
-import java.io.File;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.util.ArrayList;
import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -29,18 +38,16 @@
@RunWith(Parameterized.class)
public class R8CompiledThroughDexTest extends DesugaredLibraryTestBase {
- private static final boolean testExternal = true;
+ private static final boolean minify = false;
private final TestParameters parameters;
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- // We do not use withDexRuntimesStartingAtIncluding to exclude dex-default and therefore
- // avoid this 2 * 8 minutes test running on tools/test.py.
+ // We only run this test with ART 8 and with full desugaring to avoid the large runtime on ART.
return getTestParameters()
.withDexRuntime(Version.V8_1_0)
- .withDexRuntime(Version.V9_0_0)
- .withAllApiLevels()
+ .withApiLevel(AndroidApiLevel.B)
.build();
}
@@ -49,13 +56,61 @@
}
private static String commandLinePathFor(String string) {
+ return commandLinePathFor(Paths.get(string));
+ }
+
+ private static String commandLinePathFor(Path path) {
// We switch to absolute path due to the art frameworks requiring to run the command in a
// different folder.
- return Paths.get(string).toAbsolutePath().toString();
+ return path.toAbsolutePath().toString();
}
private static final String R8_KEEP = Paths.get("src/main/keep.txt").toAbsolutePath().toString();
+ private Pair<List<String>, Consumer<Builder>> buildArguments() {
+ ImmutableList.Builder<String> arguments = ImmutableList.builder();
+ List<Consumer<Builder>> buildup = new ArrayList<>();
+
+ arguments.add(commandLinePathFor(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR));
+ buildup.add(b -> b.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR));
+
+ arguments.add("--release");
+ buildup.add(b -> b.setMode(CompilationMode.RELEASE));
+
+ arguments.add("--min-api").add(Integer.toString(parameters.getApiLevel().getLevel()));
+ buildup.add(b -> b.setMinApiLevel(parameters.getApiLevel().getLevel()));
+
+ arguments.add("--lib").add(commandLinePathFor(ToolHelper.JAVA_8_RUNTIME));
+ buildup.add(b -> b.addLibraryFiles(ToolHelper.getJava8RuntimeJar()));
+
+ arguments.add("--pg-conf").add(commandLinePathFor(R8_KEEP));
+ buildup.add(b -> b.addProguardConfigurationFiles(Paths.get(R8_KEEP)));
+
+ if (!minify) {
+ arguments.add("--no-minification");
+ buildup.add(b -> b.setDisableMinification(true));
+ }
+
+ Consumer<Builder> consumer = b -> {};
+ for (Consumer<Builder> step : buildup) {
+ consumer = consumer.andThen(step);
+ }
+
+ return new Pair<>(arguments.build(), consumer);
+ }
+
+ private List<String> getSharedArguments() {
+ return buildArguments().getFirst();
+ }
+
+ private Consumer<Builder> getSharedBuilder() {
+ return buildArguments().getSecond();
+ }
+
+ private void printTime(String title, long start) {
+ System.out.println(title + ": " + ((System.nanoTime() - start) / 1000000000) + "s");
+ }
+
@Test
public void testR8CompiledWithR8Dex() throws Exception {
// Compile once R8_WITH_RELOCATED_DEPS_JAR using normal R8_WITH_RELOCATED_DEPS_JAR to dex,
@@ -66,67 +121,80 @@
// We use extra VM parameters for memory. The command parameters should look like:
// -Xmx512m com...R8 --release --min-api 1 --output path/to/folder --lib rt.jar
// --pg-conf R8KeepRules r8.jar
- // The 512m memory is required to make it work on ART since default is lower.
+ // The 512m memory is required to run on ART but any higher and the runtime will fail too.
- File ouputFolder = temp.newFolder("output");
+ Path outputFolder = temp.newFolder("output").toPath();
+ Path outputThroughCf = outputFolder.resolve("outThroughCf.zip");
- // Compile R8 to dex on the JVM.
- Path outputThroughCf = ouputFolder.toPath().resolve("outThroughCf.zip").toAbsolutePath();
- if (testExternal) {
+ // First run compiles with R8 in process and thus with assertions.
+ {
+ long start = System.nanoTime();
+ // Manually construct the R8 command as the test builder will change defaults compared
+ // to the CLI invocation (eg, compressed and pg-map output).
+ Builder builder = R8Command.builder().setOutput(outputThroughCf, OutputMode.DexIndexed);
+ getSharedBuilder().accept(builder);
+ R8.run(builder.build());
+ printTime("R8/JVM in-process", start);
+ }
+
+ // Second run compiles with R8 externally checking it to be equal with the first compilation.
+ // If this fails, likely due to non-determinism, then that is much faster than waiting for the
+ // Art run compilation to finish if the same error can be found directly.
+ {
+ long start = System.nanoTime();
+ Path outputThroughCfExternal = outputFolder.resolve("outThroughCf_external.zip");
+ Path r8jar = ToolHelper.R8_WITH_RELOCATED_DEPS_JAR;
ProcessResult javaProcessResult =
ToolHelper.runJava(
TestRuntime.getCheckedInJdk9(),
- Collections.singletonList(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR),
- "-Xmx512m",
- R8.class.getTypeName(),
- "--release",
- "--min-api",
- Integer.toString(parameters.getApiLevel().getLevel()),
- "--output",
- outputThroughCf.toString(),
- "--lib",
- ToolHelper.JAVA_8_RUNTIME,
- "--pg-conf",
- R8_KEEP,
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR.toAbsolutePath().toString());
+ Collections.singletonList(r8jar),
+ ImmutableList.builder()
+ .add("-Xmx1g")
+ .add(R8.class.getTypeName())
+ .add("--output")
+ .add(commandLinePathFor(outputThroughCfExternal))
+ .addAll(getSharedArguments())
+ .build()
+ .toArray(new String[0]));
+ printTime("R8/JVM external", start);
assertEquals(javaProcessResult.toString(), 0, javaProcessResult.exitCode);
- } else {
- testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
- .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
- .addKeepRuleFiles(Paths.get(R8_KEEP))
- .setMinApi(parameters.getApiLevel())
- .compile()
- .writeToZip(outputThroughCf);
+ assertTrue(
+ "The output of R8/JVM in-process and R8/JVM external differ."
+ + " Make sure you have an up-to-date compilation of "
+ + r8jar
+ + ". If not, that could very likely cause the in-process run (eg, via intellij) to"
+ + " differ from the external run which uses "
+ + r8jar
+ + ". If up-to-date, the likely cause of this error is that R8 is non-deterministic.",
+ BootstrapCurrentEqualityTest.filesAreEqual(outputThroughCf, outputThroughCfExternal));
}
- // Compile R8 to Dex on Dex, using the previous dex artifact.
+ // Finally compile R8 on the ART runtime using the already compiled DEX version of R8.
// We need the extra parameter --64 to use 64 bits frameworks.
- Path ouputThroughDex = ouputFolder.toPath().resolve("outThroughDex.zip").toAbsolutePath();
- ProcessResult artProcessResult =
- ToolHelper.runArtRaw(
- Collections.singletonList(outputThroughCf.toAbsolutePath().toString()),
- R8.class.getTypeName(),
- (ToolHelper.ArtCommandBuilder builder) ->
- builder.appendArtOption("--64").appendArtOption("-Xmx512m"),
- parameters.getRuntime().asDex().getVm(),
- true,
- "--release",
- "--min-api",
- Integer.toString(parameters.getApiLevel().getLevel()),
- "--output",
- ouputThroughDex.toString(),
- "--lib",
- commandLinePathFor(ToolHelper.JAVA_8_RUNTIME),
- "--pg-conf",
- commandLinePathFor(R8_KEEP),
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR.toAbsolutePath().toString());
- if (artProcessResult.exitCode != 0) {
- System.out.println(artProcessResult);
+ {
+ long start = System.nanoTime();
+ Path outputThroughDex = outputFolder.resolve("outThroughDex.zip");
+ ProcessResult artProcessResult =
+ ToolHelper.runArtRaw(
+ Collections.singletonList(commandLinePathFor(outputThroughCf)),
+ R8.class.getTypeName(),
+ builder -> builder.appendArtOption("--64").appendArtOption("-Xmx512m"),
+ parameters.getRuntime().asDex().getVm(),
+ true,
+ ImmutableList.builder()
+ .add("--output")
+ .add(commandLinePathFor(outputThroughDex))
+ .addAll(getSharedArguments())
+ .build()
+ .toArray(new String[0]));
+ printTime("R8/ART", start);
+ if (artProcessResult.exitCode != 0) {
+ System.out.println(artProcessResult);
+ }
+ assertEquals(0, artProcessResult.exitCode);
+ assertTrue(
+ "The output of R8/JVM in-process and R8/ART external differ.",
+ BootstrapCurrentEqualityTest.filesAreEqual(outputThroughCf, outputThroughDex));
}
- assertEquals(0, artProcessResult.exitCode);
-
- // Ensure both generated artifacts are equal.
- assertTrue(BootstrapCurrentEqualityTest.filesAreEqual(outputThroughCf, ouputThroughDex));
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java b/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
index 897f4a7..3e60058 100644
--- a/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
@@ -3,20 +3,26 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar.enclosingmethod;
-import static org.hamcrest.CoreMatchers.containsString;
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.DEFAULT_METHOD_PREFIX;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
-import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -52,11 +58,6 @@
@RunWith(Parameterized.class)
public class EnclosingMethodRewriteTest extends TestBase {
private static final Class<?> MAIN = TestClass.class;
- private static final String JAVA_OUTPUT = StringUtils.lines(
- "interface " + A.class.getName(),
- "public default int " + A.class.getName() + ".def()",
- "42"
- );
private final TestParameters parameters;
private final boolean enableMinification;
@@ -64,8 +65,7 @@
@Parameterized.Parameters(name = "{0} minification: {1}")
public static Collection<Object[]> data() {
return buildParameters(
- getTestParameters().withAllRuntimes().withAllApiLevels().build(),
- BooleanUtils.values());
+ getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
}
public EnclosingMethodRewriteTest(TestParameters parameters, boolean enableMinification) {
@@ -79,7 +79,7 @@
testForJvm()
.addTestClasspath()
.run(parameters.getRuntime(), MAIN)
- .assertSuccessWithOutput(JAVA_OUTPUT);
+ .assertSuccessWithOutputLines(getExpectedOutput());
}
@Test
@@ -88,7 +88,8 @@
Path desugared = temp.newFile("desugared.jar").toPath().toAbsolutePath();
R8FullTestBuilder builder =
testForR8(parameters.getBackend())
- .addProgramClasses(A.class, C.class, MAIN)
+ .addProgramClassesAndInnerClasses(A.class)
+ .addProgramClasses(C.class, MAIN)
.addKeepMainRule(MAIN)
.addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
.setProgramConsumer(new ArchiveConsumer(desugared))
@@ -99,41 +100,100 @@
builder.addKeepAllClassesRule();
}
builder.compile().assertNoMessages();
- try {
- testForProguard()
- .addProgramFiles(desugared)
- .addKeepMainRule(MAIN)
- .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
- .run(parameters.getRuntime(), MAIN)
- .assertSuccessWithOutput(JAVA_OUTPUT);
- } catch (CompilationFailedException e) {
- // TODO(b/70293332)
- assertThat(e.getMessage(), containsString("unresolved references"));
- assertThat(e.getMessage(), containsString(A.class.getName() + "$1"));
- }
+ testForProguard()
+ .addProgramFiles(desugared)
+ .addKeepMainRule(MAIN)
+ .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
+ .run(parameters.getRuntime(), MAIN)
+ .assertSuccess();
}
@Test
public void testR8() throws Exception {
R8FullTestBuilder builder =
testForR8(parameters.getBackend())
- .addProgramClasses(A.class, C.class, MAIN)
+ .addProgramClassesAndInnerClasses(A.class)
+ .addProgramClasses(C.class, MAIN)
.addKeepMainRule(MAIN)
.addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
.setMinApi(parameters.getApiLevel());
if (enableMinification) {
builder.addKeepAllClassesRuleWithAllowObfuscation();
} else {
- builder.addKeepAllClassesRule();
- }
- String errorType = "ClassNotFoundException";
- if (parameters.isDexRuntime()
- && parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_HOST)) {
- errorType = "NoClassDefFoundError";
+ builder.noTreeShaking().noMinification();
}
builder
+ .compile()
+ .inspect(
+ inspect -> {
+ ClassSubject cImplSubject = inspect.clazz(A.class.getTypeName() + "$1");
+ assertThat(cImplSubject, isPresent());
+
+ ClassSubject enclosingClassSubject =
+ inspect.clazz(
+ parameters.canUseDefaultAndStaticInterfaceMethods()
+ ? A.class.getTypeName()
+ : A.class.getTypeName() + COMPANION_CLASS_NAME_SUFFIX);
+ assertThat(enclosingClassSubject, isPresent());
+ assertEquals(
+ enclosingClassSubject.getDexProgramClass().getType(),
+ cImplSubject
+ .getDexProgramClass()
+ .getEnclosingMethodAttribute()
+ .getEnclosingMethod()
+ .getHolderType());
+ })
.run(parameters.getRuntime(), MAIN)
- // TODO(b/70293332)
- .assertFailureWithErrorThatMatches(containsString(errorType));
+ .apply(
+ result -> result.assertSuccessWithOutputLines(getExpectedOutput(result.inspector())));
+ }
+
+ private List<String> getExpectedOutput() {
+ return ImmutableList.of(
+ "interface " + A.class.getTypeName(),
+ "public default int " + A.class.getTypeName() + ".def()",
+ "42");
+ }
+
+ private List<String> getExpectedOutput(CodeInspector inspector) {
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+
+ MethodSubject defMethodSubject = aClassSubject.uniqueMethodWithName("def");
+ assertThat(defMethodSubject, isPresent());
+
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ String modifiers =
+ parameters.isCfRuntime()
+ || parameters.getDexRuntimeVersion().isNewerThanOrEqual(Version.V8_1_0)
+ ? "public default"
+ : "public";
+ return ImmutableList.of(
+ "interface " + aClassSubject.getFinalName(),
+ modifiers
+ + " int "
+ + aClassSubject.getFinalName()
+ + "."
+ + defMethodSubject.getFinalName()
+ + "()",
+ "42");
+ }
+
+ ClassSubject aCompanionClassSubject =
+ inspector.clazz(A.class.getTypeName() + COMPANION_CLASS_NAME_SUFFIX);
+ assertThat(aCompanionClassSubject, isPresent());
+
+ String methodNamePrefix = enableMinification ? "" : DEFAULT_METHOD_PREFIX;
+ return ImmutableList.of(
+ "class " + aCompanionClassSubject.getFinalName(),
+ "public static int "
+ + aCompanionClassSubject.getFinalName()
+ + "."
+ + methodNamePrefix
+ + defMethodSubject.getFinalName()
+ + "("
+ + aClassSubject.getFinalName()
+ + ")",
+ "42");
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java
new file mode 100644
index 0000000..b252cf4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/DeduplicateLambdasWithDefaultMethodsTest.java
@@ -0,0 +1,107 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class DeduplicateLambdasWithDefaultMethodsTest extends TestBase {
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ public DeduplicateLambdasWithDefaultMethodsTest(TestParameters parameters) {
+ parameters.assertNoneRuntime();
+ }
+
+ @Test
+ public void test() throws Exception {
+ assertEquals(
+ ImmutableSet.of(
+ Reference.classFromClass(I.class),
+ Reference.classFromClass(TestClass.class),
+ SyntheticItemsTestUtils.syntheticCompanionClass(I.class),
+ SyntheticItemsTestUtils.syntheticLambdaClass(TestClass.class, 0)),
+ testForD8(Backend.CF)
+ .addInnerClasses(getClass())
+ .setIntermediate(true)
+ .setMinApi(AndroidApiLevel.B)
+ .compile()
+ .inspector()
+ .allClasses()
+ .stream()
+ .map(FoundClassSubject::getFinalReference)
+ .collect(Collectors.toSet()));
+ }
+
+ interface I {
+ void foo();
+
+ // Lots of methods which may cause the ordering of methods on a class to change between builds.
+ default void a() {
+ System.out.print("a");
+ }
+
+ default void b() {
+ System.out.print("b");
+ }
+
+ default void c() {
+ System.out.print("c");
+ }
+
+ default void x() {
+ System.out.print("x");
+ }
+
+ default void y() {
+ System.out.print("y");
+ }
+
+ default void z() {
+ System.out.print("z");
+ }
+ }
+
+ public static class TestClass {
+ private static void foo() {
+ System.out.println("foo");
+ }
+
+ private static void pI(I i) {
+ i.a();
+ i.b();
+ i.c();
+ i.x();
+ i.y();
+ i.z();
+ i.foo();
+ }
+
+ public static void main(String[] args) {
+ // Duplication of the same lambda, each of which should become a shared instance.
+ pI(TestClass::foo);
+ pI(TestClass::foo);
+ pI(TestClass::foo);
+ pI(TestClass::foo);
+ pI(TestClass::foo);
+ pI(TestClass::foo);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java
new file mode 100644
index 0000000..90c8009
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaEqualityTest.java
@@ -0,0 +1,140 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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;
+
+/**
+ * These tests document the behavior of lambdas w.r.t identity and equality.
+ *
+ * <p>The D8 and R8 compilers take the stance that a program should not rely on either identity or
+ * equality of any lambda metafactory allocated lambda. Thus the status of these tests differ
+ * between JVM, D8/CF, D8/DEX and R8 runs as the compilers may or may not share classes and
+ * allocations as seen fit.
+ */
+@RunWith(Parameterized.class)
+public class LambdaEqualityTest extends TestBase {
+
+ static final String EXPECTED_JAVAC =
+ StringUtils.lines(
+ "Same method refs",
+ "true",
+ "true",
+ "true",
+ "Different method refs",
+ "false",
+ "false",
+ "false",
+ "Empty lambda",
+ "false",
+ "false",
+ "false");
+
+ static final String EXPECTED_D8 =
+ StringUtils.lines(
+ "Same method refs",
+ "true",
+ "true",
+ "true",
+ "Different method refs",
+ "true", // D8 will share the class for the method references.
+ "false",
+ "false",
+ "Empty lambda",
+ "false",
+ "false",
+ "false");
+
+ static final String EXPECTED_R8 =
+ StringUtils.lines(
+ "Same method refs",
+ "true",
+ "true",
+ "true",
+ "Different method refs",
+ "true", // R8 will share the class for the method references.
+ "false",
+ "false",
+ "Empty lambda",
+ "true", // R8 will eliminate the call to the impl method thus making lambdas equal.
+ "true",
+ "true");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ public LambdaEqualityTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForRuntime(parameters)
+ .addInnerClasses(LambdaEqualityTest.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED_JAVAC);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addInnerClasses(LambdaEqualityTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED_D8);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(LambdaEqualityTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(TestClass.class)
+ .addKeepMethodRules(
+ Reference.methodFromMethod(
+ TestClass.class.getDeclaredMethod(
+ "compare", String.class, MyInterface.class, MyInterface.class)))
+ .run(parameters.getRuntime(), TestClass.class)
+ // The use of invoke dynamics prohibits the optimization and sharing of lambdas in R8.
+ .assertSuccessWithOutput(parameters.isCfRuntime() ? EXPECTED_JAVAC : EXPECTED_R8);
+ }
+
+ interface MyInterface {
+ void foo();
+ }
+
+ static class TestClass {
+
+ public static void compare(String msg, MyInterface i1, MyInterface i2) {
+ System.out.println(msg);
+ System.out.println(i1.getClass() == i2.getClass());
+ System.out.println(i1 == i2);
+ System.out.println(i1.equals(i2));
+ }
+
+ public static void main(String[] args) {
+ MyInterface println = System.out::println;
+ // These lambdas are physically the same and should remain so in all cases.
+ compare("Same method refs", println, println);
+ // These lambdas can be shared as they reference the same actual function.
+ compare("Different method refs", println, System.out::println);
+ // These lambdas cannot be shared (by D8) as javac will generate a lambda$main$X for each.
+ compare("Empty lambda", () -> {}, () -> {});
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java
new file mode 100644
index 0000000..1a6e364
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaNamingConflictTest.java
@@ -0,0 +1,113 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assume.assumeTrue;
+
+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.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class LambdaNamingConflictTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("boo!");
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevel(AndroidApiLevel.B)
+ .enableApiLevelsForCf()
+ .build();
+ }
+
+ // The expected synthetic name is the context of the lambda, TestClass, and the first id.
+ private static final ClassReference CONFLICTING_NAME =
+ SyntheticItemsTestUtils.syntheticLambdaClass(TestClass.class, 0);
+
+ private final TestParameters parameters;
+
+ public LambdaNamingConflictTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClasses(I.class)
+ .addProgramClassFileData(getConflictingNameClass())
+ .addProgramClassFileData(getTransformedMainClass())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addProgramClasses(I.class)
+ .addProgramClassFileData(getConflictingNameClass())
+ .addProgramClassFileData(getTransformedMainClass())
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(o -> o.testing.allowConflictingSyntheticTypes = true)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class)
+ .addProgramClassFileData(getConflictingNameClass())
+ .addProgramClassFileData(getTransformedMainClass())
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(o -> o.testing.allowConflictingSyntheticTypes = true)
+ .addKeepMainRule(TestClass.class)
+ // Ensure that R8 cannot remove or rename the conflicting name.
+ .addKeepClassAndMembersRules(CONFLICTING_NAME.getTypeName())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ private byte[] getTransformedMainClass() throws Exception {
+ return transformer(TestClass.class)
+ .transformMethodInsnInMethod(
+ "main",
+ (opcode, owner, name, descriptor, isInterface, visitor) ->
+ visitor.visitMethodInsn(
+ opcode, CONFLICTING_NAME.getBinaryName(), name, descriptor, isInterface))
+ .transform();
+ }
+
+ private byte[] getConflictingNameClass() throws Exception {
+ return transformer(WillBeConflictingName.class)
+ .setClassDescriptor(CONFLICTING_NAME.getDescriptor())
+ .transform();
+ }
+
+ interface I {
+ void bar();
+ }
+
+ static class WillBeConflictingName {
+ public static void foo(I i) {
+ i.bar();
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ WillBeConflictingName.foo(() -> System.out.println("boo!"));
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
new file mode 100644
index 0000000..ac5b076
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
@@ -0,0 +1,281 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+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 com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Sets.SetView;
+import java.nio.file.Path;
+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;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class LambdaStaticInstanceFieldDuplicationTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("User1.1", "User1.2", "User2");
+
+ static final List<Class<?>> CLASSES =
+ ImmutableList.of(TestClass.class, MyConsumer.class, Accept.class, User1.class, User2.class);
+
+ static final List<String> CLASS_TYPE_NAMES =
+ CLASSES.stream().map(Class::getTypeName).collect(Collectors.toList());
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevel(AndroidApiLevel.J)
+ .enableApiLevelsForCf()
+ .build();
+ }
+
+ public LambdaStaticInstanceFieldDuplicationTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ // R8 does not support desugaring with class file output so this test is only valid for DEX.
+ assumeTrue(parameters.isDexRuntime());
+ runR8(false);
+ runR8(true);
+ }
+
+ private void runR8(boolean minify) throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .addKeepMainRule(TestClass.class)
+ // Prevent R8 from eliminating the lambdas by keeping the application of them.
+ .addKeepClassAndMembersRules(Accept.class)
+ .setMinApi(parameters.getApiLevel())
+ .minification(minify)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(this::checkExpectedSynthetics);
+ ;
+ }
+
+ @Test
+ public void testD8Merging() throws Exception {
+ assumeTrue(
+ "b/147485959: Merging does not happen for CF due to lack of synthetic annotations",
+ parameters.isDexRuntime());
+ boolean intermediate = true;
+ runD8Merging(intermediate);
+ }
+
+ @Test
+ public void testD8MergingNonIntermediate() throws Exception {
+ boolean intermediate = false;
+ runD8Merging(intermediate);
+ }
+
+ private void runD8Merging(boolean intermediate) throws Exception {
+ // Compile part 1 of the input (maybe intermediate)
+ Path out1 =
+ testForD8(parameters.getBackend())
+ .addProgramClasses(User1.class)
+ .addClasspathClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(intermediate)
+ .compile()
+ .writeToZip();
+
+ // Compile part 2 of the input (maybe intermediate)
+ Path out2 =
+ testForD8(parameters.getBackend())
+ .addProgramClasses(User2.class)
+ .addClasspathClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(intermediate)
+ .compile()
+ .writeToZip();
+
+ SetView<MethodReference> syntheticsInParts =
+ Sets.union(
+ getSyntheticMethods(new CodeInspector(out1)),
+ getSyntheticMethods(new CodeInspector(out2)));
+
+ // Merge parts as an intermediate artifact.
+ // This will not merge synthetics regardless of the setting of intermediate.
+ Path out3 = temp.newFolder().toPath().resolve("out3.zip");
+ testForD8(parameters.getBackend())
+ .addProgramClasses(TestClass.class, MyConsumer.class, Accept.class)
+ .addProgramFiles(out1, out2)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(true)
+ .compile()
+ .writeToZip(out3)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(inspector -> assertEquals(syntheticsInParts, getSyntheticMethods(inspector)));
+
+ // Finally do a non-intermediate merge.
+ testForD8(parameters.getBackend())
+ .addProgramFiles(out3)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(
+ inspector -> {
+ if (intermediate) {
+ // If all previous builds where intermediate then synthetics are merged.
+ checkExpectedSynthetics(inspector);
+ } else {
+ // Otherwise merging non-intermediate artifacts, synthetics will not be identified.
+ // Check that they are exactly as in the part inputs.
+ assertEquals(syntheticsInParts, getSyntheticMethods(inspector));
+ }
+ });
+ }
+
+ @Test
+ public void testD8FilePerClassFile() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ runD8FilePerMode(OutputMode.DexFilePerClassFile);
+ }
+
+ @Test
+ public void testD8FilePerClass() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ runD8FilePerMode(OutputMode.DexFilePerClass);
+ }
+
+ public void runD8FilePerMode(OutputMode outputMode) throws Exception {
+ Path perClassOutput =
+ testForD8(parameters.getBackend())
+ .setOutputMode(outputMode)
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .writeToZip();
+ testForD8()
+ .addProgramFiles(perClassOutput)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(this::checkExpectedSynthetics);
+ }
+
+ private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
+ inspector.forAllClasses(
+ clazz -> {
+ assertFalse(SyntheticItemsTestUtils.isInternalLambda(clazz.getFinalReference()));
+ clazz.forAllMethods(
+ method ->
+ assertTrue(
+ "Unexpected invoke dynamic:\n" + method.getMethod().codeToString(),
+ method.isAbstract()
+ || method
+ .streamInstructions()
+ .noneMatch(InstructionSubject::isInvokeDynamic)));
+ });
+ }
+
+ private Set<MethodReference> getSyntheticMethods(CodeInspector inspector) {
+ Set<MethodReference> methods = new HashSet<>();
+ inspector.allClasses().stream()
+ .filter(c -> !CLASS_TYPE_NAMES.contains(c.getFinalName()))
+ .forEach(
+ c ->
+ c.allMethods(m -> !m.isInstanceInitializer() && !m.isClassInitializer())
+ .forEach(m -> methods.add(m.asMethodReference())));
+ return methods;
+ }
+
+ private void checkExpectedSynthetics(CodeInspector inspector) throws Exception {
+ // Hardcoded set of expected synthetics in a "final" build. This set could change if the
+ // compiler makes any changes to the naming, sorting or grouping of synthetics. It is hard-coded
+ // here to check that the compiler generates this deterministically for any single run or merge
+ // of intermediates.
+ Set<MethodReference> expectedSynthetics =
+ ImmutableSet.of(
+ // User1 has two lambdas.
+ SyntheticItemsTestUtils.syntheticLambdaMethod(
+ User1.class, 0, MyConsumer.class.getMethod("accept", Object.class)),
+ SyntheticItemsTestUtils.syntheticLambdaMethod(
+ User1.class, 1, MyConsumer.class.getMethod("accept", Object.class)),
+ // User2 has one lambda.
+ SyntheticItemsTestUtils.syntheticLambdaMethod(
+ User2.class, 0, MyConsumer.class.getMethod("accept", Object.class)));
+ assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
+ }
+
+ interface MyConsumer {
+ void accept(Object o);
+ }
+
+ static class Accept {
+ public static void accept(Object o, MyConsumer consumer) {
+ consumer.accept(o);
+ }
+ }
+
+ static class User1 {
+
+ private static void testSystemPrintln1() {
+ // The lambda will reference a lambda$x method on User1 which is created by javac for each
+ // lambda on the class. Thus there can be no sharing unless R8 inlines the lambda method into
+ // the desugared lambda classes.
+ Accept.accept("1.1", o -> System.out.println("User" + o));
+ }
+
+ private static void testSystemPrintln2() {
+ Accept.accept("1.2", o -> System.out.println("User" + o));
+ }
+ }
+
+ static class User2 {
+
+ private static void testSystemPrintln() {
+ Accept.accept("2", o -> System.out.println("User" + o));
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ User1.testSystemPrintln1();
+ User1.testSystemPrintln2();
+ User2.testSystemPrintln();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
new file mode 100644
index 0000000..5b73125
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
@@ -0,0 +1,265 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+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 com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Sets.SetView;
+import java.nio.file.Path;
+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;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class LambdaToSysOutPrintlnDuplicationTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("User1", "User2");
+
+ static final List<Class<?>> CLASSES =
+ ImmutableList.of(TestClass.class, MyConsumer.class, Accept.class, User1.class, User2.class);
+
+ static final List<String> CLASS_TYPE_NAMES =
+ CLASSES.stream().map(Class::getTypeName).collect(Collectors.toList());
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevel(AndroidApiLevel.J)
+ .enableApiLevelsForCf()
+ .build();
+ }
+
+ public LambdaToSysOutPrintlnDuplicationTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ // R8 does not support desugaring with class file output so this test is only valid for DEX.
+ assumeTrue(parameters.isDexRuntime());
+ runR8(false);
+ runR8(true);
+ }
+
+ private void runR8(boolean minify) throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .minification(minify)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(this::checkExpectedSynthetics);
+ ;
+ }
+
+ @Test
+ public void testD8Merging() throws Exception {
+ assumeTrue(
+ "b/147485959: Merging does not happen for CF due to lack of synthetic annotations",
+ parameters.isDexRuntime());
+ boolean intermediate = true;
+ runD8Merging(intermediate);
+ }
+
+ @Test
+ public void testD8MergingNonIntermediate() throws Exception {
+ boolean intermediate = false;
+ runD8Merging(intermediate);
+ }
+
+ private void runD8Merging(boolean intermediate) throws Exception {
+ // Compile part 1 of the input (maybe intermediate)
+ Path out1 =
+ testForD8(parameters.getBackend())
+ .addProgramClasses(User1.class)
+ .addClasspathClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(intermediate)
+ .compile()
+ .writeToZip();
+
+ // Compile part 2 of the input (maybe intermediate)
+ Path out2 =
+ testForD8(parameters.getBackend())
+ .addProgramClasses(User2.class)
+ .addClasspathClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(intermediate)
+ .compile()
+ .writeToZip();
+
+ SetView<MethodReference> syntheticsInParts =
+ Sets.union(
+ getSyntheticMethods(new CodeInspector(out1)),
+ getSyntheticMethods(new CodeInspector(out2)));
+
+ // Merge parts as an intermediate artifact.
+ // This will not merge synthetics regardless of the setting of intermediate.
+ Path out3 = temp.newFolder().toPath().resolve("out3.zip");
+ testForD8(parameters.getBackend())
+ .addProgramClasses(TestClass.class, MyConsumer.class, Accept.class)
+ .addProgramFiles(out1, out2)
+ .setMinApi(parameters.getApiLevel())
+ .setIntermediate(true)
+ .compile()
+ .writeToZip(out3)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(inspector -> assertEquals(syntheticsInParts, getSyntheticMethods(inspector)));
+
+ // Finally do a non-intermediate merge.
+ testForD8(parameters.getBackend())
+ .addProgramFiles(out3)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(
+ inspector -> {
+ if (intermediate) {
+ // If all previous builds where intermediate then synthetics are merged.
+ checkExpectedSynthetics(inspector);
+ } else {
+ // Otherwise merging non-intermediate artifacts, synthetics will not be identified.
+ // Check that they are exactly as in the part inputs.
+ assertEquals(syntheticsInParts, getSyntheticMethods(inspector));
+ }
+ });
+ }
+
+ @Test
+ public void testD8FilePerClassFile() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ runD8FilePerMode(OutputMode.DexFilePerClassFile);
+ }
+
+ @Test
+ public void testD8FilePerClass() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ runD8FilePerMode(OutputMode.DexFilePerClass);
+ }
+
+ public void runD8FilePerMode(OutputMode outputMode) throws Exception {
+ Path perClassOutput =
+ testForD8(parameters.getBackend())
+ .setOutputMode(outputMode)
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .writeToZip();
+ testForD8()
+ .addProgramFiles(perClassOutput)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoOriginalsAndNoInternalSynthetics)
+ .inspect(this::checkExpectedSynthetics);
+ }
+
+ private void checkNoOriginalsAndNoInternalSynthetics(CodeInspector inspector) {
+ inspector.forAllClasses(
+ clazz -> {
+ assertFalse(SyntheticItemsTestUtils.isInternalLambda(clazz.getFinalReference()));
+ clazz.forAllMethods(
+ method ->
+ assertTrue(
+ "Unexpected invoke dynamic:\n" + method.getMethod().codeToString(),
+ method.isAbstract()
+ || method
+ .streamInstructions()
+ .noneMatch(InstructionSubject::isInvokeDynamic)));
+ });
+ }
+
+ private Set<MethodReference> getSyntheticMethods(CodeInspector inspector) {
+ Set<MethodReference> methods = new HashSet<>();
+ inspector.allClasses().stream()
+ .filter(c -> !CLASS_TYPE_NAMES.contains(c.getFinalName()))
+ .forEach(
+ c ->
+ c.allMethods(m -> !m.isInstanceInitializer())
+ .forEach(m -> methods.add(m.asMethodReference())));
+ return methods;
+ }
+
+ private void checkExpectedSynthetics(CodeInspector inspector) throws Exception {
+ // Hardcoded set of expected synthetics in a "final" build. This set could change if the
+ // compiler makes any changes to the naming, sorting or grouping of synthetics. It is hard-coded
+ // here to check that the compiler generates this deterministically for any single run or merge
+ // of intermediates.
+ Set<MethodReference> expectedSynthetics =
+ ImmutableSet.of(
+ SyntheticItemsTestUtils.syntheticLambdaMethod(
+ User1.class, 0, MyConsumer.class.getMethod("accept", Object.class)));
+ assertEquals(expectedSynthetics, getSyntheticMethods(inspector));
+ }
+
+ interface MyConsumer {
+ void accept(Object o);
+ }
+
+ static class Accept {
+ public static void accept(Object o, MyConsumer consumer) {
+ consumer.accept(o);
+ }
+ }
+
+ static class User1 {
+
+ private static void testSystemPrintln() {
+ Accept.accept("User1", System.out::println);
+ }
+ }
+
+ static class User2 {
+
+ private static void testSystemPrintln() {
+ Accept.accept("User2", System.out::println);
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ User1.testSystemPrintln();
+ User2.testSystemPrintln();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java
new file mode 100644
index 0000000..dd00acf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LegacyLambdaMergeTest.java
@@ -0,0 +1,123 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.D8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.AccessFlags;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.transformers.ClassFileTransformer.MethodInsnTransform;
+import com.android.tools.r8.transformers.ClassFileTransformer.TypeInsnTransform;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.MethodVisitor;
+
+@RunWith(Parameterized.class)
+public class LegacyLambdaMergeTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Hello, world");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+ }
+
+ public LegacyLambdaMergeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testReference() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClassFileData(getTransformedMain())
+ // Add the lambda twice (JVM just picks the first).
+ .addProgramClassFileData(getTransformedLambda())
+ .addProgramClassFileData(getTransformedLambda())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ // Merging legacy lambdas is only valid for DEX inputs, thus also not R8 applicable.
+ assumeTrue(parameters.isDexRuntime());
+ D8TestCompileResult lambda =
+ testForD8()
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(getTransformedLambda())
+ .compile();
+ testForD8()
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClassFileData(getTransformedMain())
+ // Add the lambda twice.
+ .addProgramFiles(lambda.writeToZip())
+ .addProgramFiles(lambda.writeToZip())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ private ClassReference LAMBDA =
+ Reference.classFromDescriptor(
+ Reference.classFromClass(WillBeLambda.class)
+ .getDescriptor()
+ .replace("WillBeLambda", "-$$Lambda$XYZ"));
+
+ private byte[] getTransformedLambda() throws Exception {
+ return transformer(WillBeLambda.class)
+ .setClassDescriptor(LAMBDA.getDescriptor())
+ .setAccessFlags(AccessFlags::setSynthetic)
+ .transform();
+ }
+
+ private byte[] getTransformedMain() throws Exception {
+ return transformer(TestClass.class)
+ .transformMethodInsnInMethod(
+ "main",
+ new MethodInsnTransform() {
+ @Override
+ public void visitMethodInsn(
+ int opcode,
+ String owner,
+ String name,
+ String descriptor,
+ boolean isInterface,
+ MethodVisitor visitor) {
+ visitor.visitMethodInsn(
+ opcode, LAMBDA.getBinaryName(), name, descriptor, isInterface);
+ }
+ })
+ .transformTypeInsnInMethod(
+ "main",
+ new TypeInsnTransform() {
+ @Override
+ public void visitTypeInsn(int opcode, String type, MethodVisitor visitor) {
+ visitor.visitTypeInsn(opcode, LAMBDA.getBinaryName());
+ }
+ })
+ .transform();
+ }
+
+ static class WillBeLambda {
+ public void foo() {
+ System.out.println("Hello, world");
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new WillBeLambda().foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java
new file mode 100644
index 0000000..35e31d5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java
@@ -0,0 +1,106 @@
+// 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.desugar.lambdas.mergedcontext;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+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;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MergedContextTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("B::foo", "C::bar");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+ }
+
+ public MergedContextTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(TestClass.class, A.class, B.class, C.class)
+ .addKeepClassAndMembersRules(TestClass.class)
+ .addKeepRules("-repackageclasses \"repackaged\"")
+ .enableInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .addHorizontallyMergedClassesInspector(
+ inspector -> {
+ inspector.assertClassNotMerged(C.class);
+ inspector.assertMergedInto(B.class, A.class);
+ })
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ /* This class will be merged with class B (with A being the result). This class has a package
+ * protected access to ensure that it cannot be repackaged. */
+ @NeverClassInline
+ public static class A {
+
+ @NeverInline
+ public void ensureNotRepackaged() {
+ TestClass.packageProtectedMethodToDisableRepackage();
+ }
+ }
+
+ /* This class is merged into A. */
+ @NeverClassInline
+ public static class B {
+
+ @NeverInline
+ public Runnable foo() {
+ C c = new C();
+ // This synthetic lambda class uses package protected access to C. Its context will initially
+ // be B, thus the synthetic will internally be B-$$Synthetic. The lambda can be repackaged
+ // together with the accessed class C. However, once A and B are merged as A, the context
+ // implicitly changes. If repackaging does not either see or adjust the context, the result
+ // will be that the external synthetic lambda will become A-$$Synthetic,
+ // with the consequence that the call to repackaged.C.protectedMethod() will throw IAE.
+ return () -> {
+ System.out.println("B::foo");
+ c.packageProtectedMethod();
+ };
+ }
+ }
+
+ @NeverClassInline
+ @NoHorizontalClassMerging
+ public static class C {
+
+ @NeverInline
+ void packageProtectedMethod() {
+ System.out.println("C::bar");
+ }
+ }
+
+ static class TestClass {
+
+ static void packageProtectedMethodToDisableRepackage() {
+ if (System.nanoTime() < 0) {
+ throw new RuntimeException();
+ }
+ }
+
+ public static void main(String[] args) {
+ new A().ensureNotRepackaged();
+ new B().foo().run();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
index e4447b53..8a37cd0 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
@@ -50,7 +50,7 @@
return getTestParameters()
.withCfRuntimesStartingFromIncluding(CfVm.JDK11)
.withDexRuntimes()
- .withAllApiLevels()
+ .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
.build();
}
@@ -107,11 +107,7 @@
.addKeepAllAttributes()
.setMinApi(parameters.getApiLevel())
.addProgramFiles(classesOfNest(nestID))
- .addOptionsModification(
- options -> {
- options.enableNestBasedAccessDesugaring = true;
- options.enableNestReduction = false;
- })
+ .addOptionsModification(options -> options.enableNestReduction = false)
.compile()
.run(parameters.getRuntime(), getMainClass(nestID))
.assertSuccessWithOutput(getExpectedResult(nestID));
@@ -125,7 +121,6 @@
testForD8()
.setMinApi(parameters.getApiLevel())
.addProgramFiles(classesOfNest(nestID))
- .addOptionsModification(options -> options.enableNestBasedAccessDesugaring = true)
.compile()
.run(parameters.getRuntime(), getMainClass(nestID))
.assertSuccessWithOutput(getExpectedResult(nestID));
@@ -136,10 +131,6 @@
throws CompilationFailedException {
return testForD8(getStaticTemp())
.addProgramFiles(JAR)
- .addOptionsModification(
- options -> {
- options.enableNestBasedAccessDesugaring = true;
- })
.setMinApi(minApi)
.compile();
}
@@ -150,12 +141,9 @@
.noTreeShaking()
.noMinification()
.addKeepAllAttributes()
- .addOptionsModification(
- options -> {
- options.enableNestBasedAccessDesugaring = true;
- options.enableNestReduction = false;
- })
+ .addOptionsModification(options -> options.enableNestReduction = false)
.addProgramFiles(JAR)
+ .addInliningAnnotations()
.setMinApi(minApi)
.compile();
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
index 6ebe0db..bf9a226 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.desugar.nestaccesscontrol;
import static junit.framework.TestCase.assertTrue;
-import static org.hamcrest.CoreMatchers.containsString;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -51,10 +50,13 @@
.setMinApi(parameters.getApiLevel())
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_11_JAR)
.addKeepRuleFiles(MAIN_KEEP)
+ // TODO(b/177967938): Investigate why this is needed.
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ builder -> builder.addDontWarnJavaLangInvoke().addDontWarnJavaNioFile(),
+ builder -> builder.addDontWarnJavaLangInvoke("StringConcatFactory"))
.addOptionsModification(opt -> opt.ignoreMissingClasses = true)
- .allowDiagnosticWarningMessages()
.compile()
- .assertAllWarningMessagesMatch(containsString("Missing class "))
.inspect(this::assertNotEmpty)
.inspect(Java11R8CompilationTest::assertNoNests);
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
index 9d01c91..c55df8c 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring;
+import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -37,7 +37,7 @@
.withCfRuntimesStartingFromIncluding(CfVm.JDK11)
.withDexRuntime(DexVm.Version.first())
.withDexRuntime(DexVm.Version.last())
- .withAllApiLevels()
+ .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
.build();
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
index 816a233..aa22447 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
@@ -94,6 +94,7 @@
options.enableClassInlining = false;
})
.addProgramFiles(classesMatching(outerNestName))
+ .addInliningAnnotations()
.compile()
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
index 7f2fede..66e2ec7 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
@@ -4,12 +4,15 @@
package com.android.tools.r8.desugar.nestaccesscontrol;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.CLASSES_PATH;
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.CLASS_NAMES;
import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
import static java.util.stream.Collectors.toList;
import static org.hamcrest.core.StringContains.containsString;
import static org.hamcrest.core.StringEndsWith.endsWith;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -20,9 +23,12 @@
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.ToolHelper.DexVm;
import com.android.tools.r8.errors.IncompleteNestNestDesugarDiagnosic;
+import com.android.tools.r8.errors.InterfaceDesugarMissingTypeDiagnostic;
import com.android.tools.r8.errors.MissingNestHostNestDesugarDiagnostic;
+import com.android.tools.r8.shaking.MissingClassesDiagnostic;
import java.nio.file.Path;
import java.util.List;
import org.hamcrest.Matcher;
@@ -47,17 +53,19 @@
.withCfRuntimesStartingFromIncluding(CfVm.JDK11)
.withDexRuntime(DexVm.Version.first())
.withDexRuntime(DexVm.Version.last())
- .withAllApiLevels()
+ .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
.build();
}
@Test
- public void testWarningD8() throws Exception {
+ public void testD8() throws Exception {
Assume.assumeTrue(parameters.isDexRuntime());
- testIncompleteNestWarning(true, true);
- testMissingNestHostWarning(true, true);
+ testMissingNestHostError(true);
+ testIncompleteNestError(true);
}
-
+ // TODO R8:
+ // appView.options().reportMissingNestHost(clazz);
+ // clazz.clearNestHost();
@Test
public void testWarningR8() throws Exception {
testIncompleteNestWarning(false, parameters.isDexRuntime());
@@ -66,8 +74,8 @@
@Test
public void testErrorR8() {
- testMissingNestHostError();
- testIncompleteNestError();
+ testMissingNestHostError(false);
+ testIncompleteNestError(false);
}
private TestCompilerBuilder<?, ?, ?, ?, ?> compileOnlyClassesMatching(
@@ -81,10 +89,7 @@
.map(name -> CLASSES_PATH.resolve(name + CLASS_EXTENSION))
.collect(toList());
if (d8) {
- return testForD8()
- .setMinApi(parameters.getApiLevel())
- .addProgramFiles(matchingClasses)
- .addOptionsModification(options -> options.enableNestBasedAccessDesugaring = true);
+ return testForD8().setMinApi(parameters.getApiLevel()).addProgramFiles(matchingClasses);
} else {
return testForR8(parameters.getBackend())
.noTreeShaking()
@@ -92,23 +97,49 @@
.addKeepAllAttributes()
.setMinApi(parameters.getApiLevel())
.addProgramFiles(matchingClasses)
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .addDontWarn("java.lang.invoke.StringConcatFactory")
.addOptionsModification(
options -> {
- options.enableNestBasedAccessDesugaring = true;
options.ignoreMissingClasses = ignoreMissingClasses;
+ options.testing.enableExperimentalMissingClassesReporting = true;
})
.allowDiagnosticWarningMessages(allowDiagnosticWarningMessages);
}
}
- private void testMissingNestHostError() {
+ private void testMissingNestHostError(boolean d8) {
try {
Matcher<String> innerClassMatcher =
containsString("BasicNestHostWithInnerClassMethods$BasicNestedClass");
- compileOnlyClassesMatching(innerClassMatcher, false, false, false)
+ compileOnlyClassesMatching(innerClassMatcher, d8, false, false)
.compileWithExpectedDiagnostics(
diagnostics -> {
- diagnostics.assertErrorMessageThatMatches(containsString("requires its nest host"));
+ if (d8) {
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(
+ diagnosticType(MissingNestHostNestDesugarDiagnostic.class));
+
+ MissingNestHostNestDesugarDiagnostic diagnostic =
+ (MissingNestHostNestDesugarDiagnostic) diagnostics.getErrors().get(0);
+ assertEquals(
+ "Class BasicNestHostWithInnerClassMethods$BasicNestedClass requires its nest "
+ + "host BasicNestHostWithInnerClassMethods to be on program or class "
+ + "path.",
+ diagnostic.getDiagnosticMessage());
+ } else {
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(diagnosticType(MissingClassesDiagnostic.class));
+
+ MissingClassesDiagnostic diagnostic =
+ (MissingClassesDiagnostic) diagnostics.getErrors().get(0);
+ assertEquals(1, diagnostic.getMissingClasses().size());
+ assertEquals(
+ "nesthostexample.BasicNestHostWithInnerClassMethods",
+ diagnostic.getMissingClasses().iterator().next().getTypeName());
+ }
});
} catch (CompilationFailedException e) {
// Expected failure.
@@ -117,14 +148,37 @@
fail("Should have raised an exception for missing nest host");
}
- private void testIncompleteNestError() {
+ private void testIncompleteNestError(boolean d8) {
try {
Matcher<String> innerClassMatcher = endsWith("BasicNestHostWithInnerClassMethods");
- compileOnlyClassesMatching(innerClassMatcher, false, false, false)
+ compileOnlyClassesMatching(innerClassMatcher, d8, false, false)
.compileWithExpectedDiagnostics(
diagnostics -> {
- diagnostics.assertErrorMessageThatMatches(
- containsString("requires its nest mates"));
+ if (d8) {
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(diagnosticType(IncompleteNestNestDesugarDiagnosic.class));
+
+ IncompleteNestNestDesugarDiagnosic diagnostic =
+ (IncompleteNestNestDesugarDiagnosic) diagnostics.getErrors().get(0);
+ assertEquals(
+ "Compilation of classes nesthostexample.BasicNestHostWithInnerClassMethods "
+ + "requires its nest mates "
+ + "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass "
+ + "(unavailable) to be on program or class path.",
+ diagnostic.getDiagnosticMessage());
+ } else {
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(diagnosticType(MissingClassesDiagnostic.class));
+
+ MissingClassesDiagnostic diagnostic =
+ (MissingClassesDiagnostic) diagnostics.getErrors().get(0);
+ assertEquals(1, diagnostic.getMissingClasses().size());
+ assertEquals(
+ "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass",
+ diagnostic.getMissingClasses().iterator().next().getTypeName());
+ }
});
} catch (Exception e) {
// Expected failure.
@@ -139,15 +193,31 @@
TestCompileResult<?, ?> compileResult =
compileOnlyClassesMatching(innerClassMatcher, d8, !d8, true).compile();
assertTrue(compileResult.getDiagnosticMessages().getWarnings().size() >= 1);
- if (desugarWarning) {
+ if (d8 && desugarWarning) {
assertTrue(
compileResult.getDiagnosticMessages().getWarnings().stream()
.anyMatch(warn -> warn instanceof MissingNestHostNestDesugarDiagnostic));
- } else if (!d8) {
+ }
+ if (!d8) {
// R8 should raise extra warning when cleaning the nest.
- assertTrue(
- compileResult.getDiagnosticMessages().getWarnings().stream()
- .anyMatch(warn -> warn.getDiagnosticMessage().contains("requires its nest host")));
+ compileResult.inspectDiagnosticMessages(
+ diagnostics -> {
+ diagnostics.assertOnlyWarnings();
+ if (parameters.isCfRuntime() || parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ diagnostics.assertWarningsMatch(diagnosticType(MissingClassesDiagnostic.class));
+ } else {
+ diagnostics.assertWarningsMatch(
+ diagnosticType(MissingClassesDiagnostic.class),
+ diagnosticType(InterfaceDesugarMissingTypeDiagnostic.class));
+ }
+
+ MissingClassesDiagnostic diagnostic =
+ (MissingClassesDiagnostic) diagnostics.getWarnings().get(0);
+ assertEquals(1, diagnostic.getMissingClasses().size());
+ assertEquals(
+ "nesthostexample.BasicNestHostWithInnerClassMethods",
+ diagnostic.getMissingClasses().iterator().next().getTypeName());
+ });
}
}
@@ -156,13 +226,32 @@
TestCompileResult<?, ?> compileResult =
compileOnlyClassesMatching(innerClassMatcher, d8, !d8, true).compile();
assertTrue(compileResult.getDiagnosticMessages().getWarnings().size() >= 1);
- if (desugarWarning) {
+ if (d8 && desugarWarning) {
assertTrue(
compileResult.getDiagnosticMessages().getWarnings().stream()
.anyMatch(warn -> warn instanceof IncompleteNestNestDesugarDiagnosic));
- } else if (!d8) {
+ }
+ if (!d8) {
// R8 should raise extra warning when cleaning the nest.
- compileResult.assertWarningMessageThatMatches(containsString("requires its nest mates"));
+ compileResult.inspectDiagnosticMessages(
+ diagnostics -> {
+ diagnostics.assertOnlyWarnings();
+ if (parameters.isCfRuntime() || parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ diagnostics.assertWarningsMatch(diagnosticType(MissingClassesDiagnostic.class));
+ } else {
+ diagnostics.assertWarningsMatch(
+ diagnosticType(MissingClassesDiagnostic.class),
+ diagnosticType(InterfaceDesugarMissingTypeDiagnostic.class));
+ }
+
+ MissingClassesDiagnostic diagnostic =
+ (MissingClassesDiagnostic) diagnostics.getWarnings().get(0);
+ assertNotNull(diagnostic);
+ assertEquals(1, diagnostic.getMissingClasses().size());
+ assertEquals(
+ "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass",
+ diagnostic.getMissingClasses().iterator().next().getTypeName());
+ });
}
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
index 1ed0e0a..85bade9 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
@@ -33,7 +33,7 @@
.withCfRuntimesStartingFromIncluding(CfVm.JDK11)
.withDexRuntime(DexVm.Version.first())
.withDexRuntime(DexVm.Version.last())
- .withAllApiLevels()
+ .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
.build();
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestOnProgramAndClassPathTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestOnProgramAndClassPathTest.java
index bb59533..4029469 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestOnProgramAndClassPathTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestOnProgramAndClassPathTest.java
@@ -99,9 +99,7 @@
testForD8()
.addProgramFiles(inner.writeToZip(), host.writeToZip())
.setMinApi(parameters.getApiLevel())
- .addOptionsModification(options -> options.enableNestBasedAccessDesugaring = true)
.compile()
- .inspect(inspector -> assertEquals(3, inspector.allClasses().size()))
.run(parameters.getRuntime(), getMainClass("constructors"))
.assertSuccessWithOutput(getExpectedResult("constructors"));
}
@@ -117,7 +115,6 @@
.setMinApi(parameters.getApiLevel())
.addProgramFiles(matchingClasses)
.addClasspathFiles(JAR)
- .addOptionsModification(options -> options.enableNestBasedAccessDesugaring = true)
.compile();
}
diff --git a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MissingMethodTest.java b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MissingMethodTest.java
index f147d3b..d36953c 100644
--- a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MissingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MissingMethodTest.java
@@ -6,7 +6,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRunResult;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -28,33 +27,19 @@
@Test
public void testReference() throws Exception {
- TestRunResult<?> result =
- testForRuntime(parameters)
- .addProgramClassFileData(InterfaceDump.dump(), MainDump.dump())
- .run(parameters.getRuntime(), "Main");
- if (parameters.isDexRuntime()
- && parameters.getApiLevel().isLessThan(apiLevelWithStaticInterfaceMethodsSupport())) {
- // TODO(b/69835274): Desugaring should preserve exception.
- result.assertFailureWithErrorThatThrows(NoClassDefFoundError.class);
- } else {
- result.assertFailureWithErrorThatThrows(NoSuchMethodError.class);
- }
+ testForRuntime(parameters)
+ .addProgramClassFileData(InterfaceDump.dump(), MainDump.dump())
+ .run(parameters.getRuntime(), "Main")
+ .assertFailureWithErrorThatThrows(NoSuchMethodError.class);
}
@Test
public void testR8() throws Exception {
- TestRunResult<?> result =
- testForR8(parameters.getBackend())
- .addProgramClassFileData(InterfaceDump.dump(), MainDump.dump())
- .addKeepMainRule("Main")
- .setMinApi(parameters.getApiLevel())
- .run(parameters.getRuntime(), "Main");
- if (parameters.isDexRuntime()
- && parameters.getApiLevel().isLessThan(apiLevelWithStaticInterfaceMethodsSupport())) {
- // TODO(b/69835274): Desugaring should preserve exception.
- result.assertFailureWithErrorThatThrows(NoClassDefFoundError.class);
- } else {
- result.assertFailureWithErrorThatThrows(NoSuchMethodError.class);
- }
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(InterfaceDump.dump(), MainDump.dump())
+ .addKeepMainRule("Main")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), "Main")
+ .assertFailureWithErrorThatThrows(NoSuchMethodError.class);
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/twr/TwrCloseResourceDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/twr/TwrCloseResourceDuplicationTest.java
new file mode 100644
index 0000000..aac4a9e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/twr/TwrCloseResourceDuplicationTest.java
@@ -0,0 +1,160 @@
+// 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.desugar.twr;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+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;
+import com.android.tools.r8.utils.ZipUtils;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
+import java.util.List;
+import java.util.jar.JarFile;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class TwrCloseResourceDuplicationTest extends TestBase {
+
+ static final int INPUT_CLASSES = 3;
+
+ static final String EXPECTED =
+ StringUtils.lines(
+ "foo opened 1",
+ "foo post close 1",
+ "foo opened 2",
+ "foo caught from 2: RuntimeException",
+ "foo post close 2",
+ "bar opened 1",
+ "bar post close 1",
+ "bar opened 2",
+ "bar caught from 2: RuntimeException",
+ "bar post close 2");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ public TwrCloseResourceDuplicationTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private String getZipFile() throws IOException {
+ return ZipUtils.ZipBuilder.builder(temp.newFile("file.zip").toPath())
+ // DEX VMs from 4.4 up-to 9.0 including, will fail if no entry is added.
+ .addBytes("entry", new byte[1])
+ .build()
+ .toString();
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addInnerClasses(getClass())
+ .run(parameters.getRuntime(), TestClass.class, getZipFile())
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class, getZipFile())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(
+ inspector -> {
+ // There should be exactly one synthetic class besides the three program classes.
+ int expectedSynthetics =
+ parameters.getApiLevel().isLessThan(apiLevelWithTwrCloseResourceSupport())
+ ? 1
+ : 0;
+ assertEquals(INPUT_CLASSES + expectedSynthetics, inspector.allClasses().size());
+ });
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(Foo.class, Bar.class)
+ .applyIf(
+ parameters.getApiLevel().isLessThan(apiLevelWithTwrCloseResourceSupport()),
+ builder -> builder.addDontWarn("java.lang.AutoCloseable"))
+ .setMinApi(parameters.getApiLevel())
+ .noMinification()
+ .run(parameters.getRuntime(), TestClass.class, getZipFile())
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(
+ inspector -> {
+ // R8 will optimize the generated methods for the two cases below where the thrown
+ // exception is known or not, thus the synthetic methods will be 2.
+ int expectedSynthetics =
+ parameters.getApiLevel().isLessThan(apiLevelWithTwrCloseResourceSupport())
+ ? 2
+ : 0;
+ List<FoundClassSubject> foundClassSubjects = inspector.allClasses();
+ assertEquals(INPUT_CLASSES + expectedSynthetics, foundClassSubjects.size());
+ });
+ }
+
+ static class Foo {
+ void foo(String name) {
+ try (JarFile f = new JarFile(name)) {
+ System.out.println("foo opened 1");
+ } catch (Exception e) {
+ System.out.println("foo caught from 1: " + e.getClass().getSimpleName());
+ } finally {
+ System.out.println("foo post close 1");
+ }
+ try (JarFile f = new JarFile(name)) {
+ System.out.println("foo opened 2");
+ throw new RuntimeException();
+ } catch (Exception e) {
+ System.out.println("foo caught from 2: " + e.getClass().getSimpleName());
+ } finally {
+ System.out.println("foo post close 2");
+ }
+ }
+ }
+
+ static class Bar {
+ void bar(String name) {
+ try (JarFile f = new JarFile(name)) {
+ System.out.println("bar opened 1");
+ } catch (Exception e) {
+ System.out.println("bar caught from 1: " + e.getClass().getSimpleName());
+ } finally {
+ System.out.println("bar post close 1");
+ }
+ try (JarFile f = new JarFile(name)) {
+ System.out.println("bar opened 2");
+ throw new RuntimeException();
+ } catch (Exception e) {
+ System.out.println("bar caught from 2: " + e.getClass().getSimpleName());
+ } finally {
+ System.out.println("bar post close 2");
+ }
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new Foo().foo(args[0]);
+ new Bar().bar(args[0]);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java b/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
index 934a15b..e76e476 100644
--- a/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/lambdanames/PackageDependentLambdaNamesTest.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -47,11 +48,11 @@
if (parameters.isDexRuntime()) {
result.inspect(
inspector -> {
- // When in the same package we expect the two System.out::print lambdas to be shared.
+ // With the hygienic synthetics the reference to System.out::print can always be shared.
assertEquals(
- samePackage ? 2 : 3,
+ 2,
inspector.allClasses().stream()
- .filter(c -> c.isSynthesizedJavaLambdaClass())
+ .filter(FoundClassSubject::isSynthesizedJavaLambdaClass)
.count());
});
}
@@ -85,7 +86,6 @@
return transformer.transform();
}
- @FunctionalInterface
public interface StringConsumer {
void accept(String arg);
}
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java
index c9dd274..780696e 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java
@@ -62,8 +62,7 @@
r8FullTestBuilder
.enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
- .noMinification()
- .addOptionsModification(o -> o.testing.deterministicSortingBasedOnDexType = true);
+ .noMinification();
ProcessResult processResult =
testDexSplitter(
parameters,
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java b/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java
index c41a1d1..dce9fbc 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java
@@ -143,6 +143,7 @@
.addProgramClasses(baseClasses)
.addFeatureSplit(
builder -> simpleSplitProvider(builder, featureOutput, temp, featureClasses))
+ .addInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(SplitRunner.class)
.addKeepClassRules(toRun);
@@ -182,6 +183,7 @@
.addClasspathClasses(baseClasses)
.addClasspathClasses(RunInterface.class)
.addKeepAllClassesRule()
+ .addInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java b/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
index b9eabe6..89088ac 100644
--- a/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
+++ b/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
@@ -86,7 +86,8 @@
try {
testForD8()
.apply(addTestClassWithOrigin())
- .addOptionsModification(options -> options.testing.hookInIrConversion = () -> throwNPE())
+ .addOptionsModification(
+ options -> options.testing.hookInIrConversion = ErrorDuringIrConversionTest::throwNPE)
.compileWithExpectedDiagnostics(
diagnostics -> {
// Check that the error is reported as an error to the diagnostics handler.
diff --git a/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java b/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java
index 3dabac7..4b1bb9e 100644
--- a/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java
+++ b/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java
@@ -48,12 +48,11 @@
})
.allowDiagnosticInfoMessages()
.compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics
- .assertOnlyInfos()
- .assertInfosCount(1)
- .assertInfosMatch(diagnosticMessage(startsWith(MISSING_CLASS_MESSAGE_PREFIX)));
- });
+ diagnostics ->
+ diagnostics
+ .assertOnlyInfos()
+ .assertInfosCount(1)
+ .assertInfosMatch(diagnosticMessage(startsWith(MISSING_CLASS_MESSAGE_PREFIX))));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
index 20362c3..0bc6b67 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
@@ -51,6 +51,7 @@
.addKeepRuntimeVisibleAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
+ .enableMemberValuePropagationAnnotations()
.enableNoVerticalClassMergingAnnotations()
.addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
.allowDiagnosticInfoMessages()
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
index 89395ef..b21cbd0 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
@@ -97,13 +97,6 @@
return testForR8(Backend.CF)
.addProgramClasses(ToStringLib.class, ToStringLib.LibEnum.class)
.addKeepRules(enumKeepRules.getKeepRules())
- // TODO(b/160535629): Work-around on some optimizations relying on $VALUES name.
- .addKeepRules(
- "-keep enum "
- + ToStringLib.LibEnum.class.getName()
- + " { static "
- + ToStringLib.LibEnum.class.getName()
- + "[] $VALUES; }")
.addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
.addKeepMethodRules(
Reference.methodFromMethod(
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
index a4f280c..3c48865 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
@@ -4,8 +4,10 @@
package com.android.tools.r8.enumunboxing.kotlin;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static com.android.tools.r8.KotlinTestBase.getCompileMemoizer;
import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
+import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
@@ -68,18 +70,25 @@
public void testEnumUnboxing() throws Exception {
assumeTrue(parameters.isDexRuntime());
testForR8(parameters.getBackend())
- .addProgramFiles(jars.getForConfiguration(kotlinCompiler, targetVersion))
+ .addProgramFiles(
+ jars.getForConfiguration(kotlinCompiler, targetVersion),
+ ToolHelper.getKotlinStdlibJar(kotlinCompiler))
.addKeepMainRule(PKG + ".MainKt")
.addKeepRules(enumKeepRules.getKeepRules())
.addKeepRuntimeVisibleAnnotations()
.addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
- .allowDiagnosticInfoMessages()
+ .allowDiagnosticMessages()
.setMinApi(parameters.getApiLevel())
.compile()
.inspectDiagnosticMessages(
- m -> {
+ messages -> {
+ messages
+ .assertNoErrors()
+ .assertAllWarningsMatch(
+ diagnosticMessage(
+ containsString("Resource 'META-INF/MANIFEST.MF' already exists.")));
assertEnumIsUnboxed(
- PKG + ".Color", SimpleKotlinEnumUnboxingTest.class.getSimpleName(), m);
+ PKG + ".Color", SimpleKotlinEnumUnboxingTest.class.getSimpleName(), messages);
})
.run(parameters.getRuntime(), PKG + ".MainKt")
.assertSuccessWithOutputLines("RED", "GREEN", "BLUE");
diff --git a/src/test/java/com/android/tools/r8/graph/DexTypeTest.java b/src/test/java/com/android/tools/r8/graph/DexTypeTest.java
index 82ee9e8..83164c5 100644
--- a/src/test/java/com/android/tools/r8/graph/DexTypeTest.java
+++ b/src/test/java/com/android/tools/r8/graph/DexTypeTest.java
@@ -9,9 +9,11 @@
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.Timing;
+import java.util.HashSet;
import java.util.Set;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -53,7 +55,7 @@
// class ArrayList implements List
DexType arrayList = factory.createType("Ljava/util/ArrayList;");
- Set<DexType> interfaces = appInfo.implementedInterfaces(arrayList);
+ Set<DexType> interfaces = setOfAll(appInfo.implementedInterfaces(arrayList));
assertThat(interfaces, hasItems(serializable));
assertThat(interfaces, hasItems(iterable));
assertThat(interfaces, hasItems(collection));
@@ -62,7 +64,7 @@
// class LinkedList implements List, Deque
DexType linkedList = factory.createType("Ljava/util/LinkedList;");
- interfaces = appInfo.implementedInterfaces(linkedList);
+ interfaces = setOfAll(appInfo.implementedInterfaces(linkedList));
assertThat(interfaces, hasItems(serializable));
assertThat(interfaces, hasItems(iterable));
assertThat(interfaces, hasItems(collection));
@@ -71,6 +73,12 @@
assertThat(interfaces, hasItems(queue));
}
+ private static Set<DexType> setOfAll(InterfaceCollection interfaces) {
+ HashSet<DexType> set = new HashSet<>(interfaces.size());
+ interfaces.forEach((iface, ignoredIsKnown) -> set.add(iface));
+ return set;
+ }
+
@Test
public void implementedInterfaces_collections_kotlin() {
DexType iterable = factory.createType("Ljava/lang/Iterable;");
@@ -84,13 +92,13 @@
DexType ktAbsList = factory.createType("Lkotlin/collections/AbstractList;");
DexType ktAbsSet = factory.createType("Lkotlin/collections/AbstractSet;");
- Set<DexType> interfaces = appInfo.implementedInterfaces(ktAbsList);
+ Set<DexType> interfaces = setOfAll(appInfo.implementedInterfaces(ktAbsList));
assertThat(interfaces, hasItems(iterable));
assertThat(interfaces, hasItems(collection));
assertThat(interfaces, hasItems(list));
assertThat(interfaces, not(hasItems(set)));
- interfaces = appInfo.implementedInterfaces(ktAbsSet);
+ interfaces = setOfAll(appInfo.implementedInterfaces(ktAbsSet));
assertThat(interfaces, hasItems(iterable));
assertThat(interfaces, hasItems(collection));
assertThat(interfaces, hasItems(set));
@@ -107,7 +115,7 @@
DexType pType = factory.createType("Ljava/lang/reflect/ParameterizedType;");
DexType klass = factory.createType("Ljava/lang/Class;");
- Set<DexType> interfaces = appInfo.implementedInterfaces(klass);
+ Set<DexType> interfaces = setOfAll(appInfo.implementedInterfaces(klass));
assertThat(interfaces, hasItems(serializable));
assertThat(interfaces, hasItems(annotatedElement));
assertThat(interfaces, hasItems(genericDeclaration));
@@ -130,7 +138,7 @@
DexType mutableReference0 =
factory.createType("Lkotlin/jvm/internal/MutablePropertyReference0;");
- Set<DexType> interfaces = appInfo.implementedInterfaces(mutableReference0);
+ Set<DexType> interfaces = setOfAll(appInfo.implementedInterfaces(mutableReference0));
assertThat(interfaces, hasItems(kCallable));
assertThat(interfaces, hasItems(kProperty));
assertThat(interfaces, hasItems(kMutableProperty));
@@ -147,15 +155,14 @@
// interface Function0 : Function
DexType function0 = factory.createType("Lkotlin/jvm/functions/Function0;");
- Set<DexType> interfaces = appInfo.implementedInterfaces(lambda);
+ Set<DexType> interfaces = setOfAll(appInfo.implementedInterfaces(lambda));
assertThat(interfaces, not(hasItems(lambda)));
assertThat(interfaces, hasItems(function));
assertThat(interfaces, hasItems(functionBase));
- interfaces = appInfo.implementedInterfaces(function0);
+ interfaces = setOfAll(appInfo.implementedInterfaces(function0));
assertThat(interfaces, hasItems(function0));
assertThat(interfaces, hasItems(function));
assertThat(interfaces, not(hasItems(functionBase)));
}
-
}
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 213db97..7277139 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -65,7 +65,7 @@
}
@Test
- public void testSuperTypeOfExceptions() throws Exception {
+ public void testSuperTypeOfExceptions() {
AssertUtils.assertFailsCompilation(
() ->
testForR8(parameters.getBackend())
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
index 183ae6b..509bfa2 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
@@ -34,20 +34,20 @@
@Test
public void testRuntime() throws Exception {
testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(I.class, Main.class)
+ .addProgramClassesAndInnerClasses(Main.class)
+ .addProgramClasses(I.class)
.addProgramClassFileData(getClassWithTransformedInvoked())
.run(parameters.getRuntime(), Main.class)
- .assertFailureWithErrorThatThrows(
- parameters.isCfRuntime()
- ? VerifyError.class
- // TODO(b/144410139): Consider making this a compilation failure.
- : NoClassDefFoundError.class);
+ // TODO(b/144410139): Consider making this a compilation failure when generating DEX.
+ .assertSuccessWithOutputLinesIf(parameters.isDexRuntime(), "Hello World!")
+ .assertFailureWithErrorThatThrowsIf(parameters.isCfRuntime(), VerifyError.class);
}
@Test
public void testR8() throws Exception {
testForR8(parameters.getBackend())
- .addProgramClasses(I.class, Main.class)
+ .addProgramClassesAndInnerClasses(Main.class)
+ .addProgramClasses(I.class)
.addProgramClassFileData(getClassWithTransformedInvoked())
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -56,7 +56,7 @@
parameters.isCfRuntime()
? VerifyError.class
// TODO(b/144410139): Consider making this a compilation failure.
- : NoClassDefFoundError.class);
+ : NullPointerException.class);
}
private byte[] getClassWithTransformedInvoked() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToSubclassTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToSubclassTest.java
index b439787..9c44e2a 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToSubclassTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToSubclassTest.java
@@ -42,25 +42,21 @@
@Test
public void testRuntime() throws Exception {
testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(EmptySubC.class, C.class, Main.class)
+ .addProgramClasses(EmptySubC.class, C.class, D.class, Main.class)
.addProgramClassFileData(getClassBWithTransformedInvoked(holder))
.run(parameters.getRuntime(), Main.class)
- // The failures are very different from one back-end to another: verification error,
- // invalid invoke-super, segmentation fault, NoSuchMethod, etc.
- .assertFailure();
+ .assertSuccessWithOutputLines("Should not be called.");
}
@Test
public void testR8() throws Exception {
testForR8(parameters.getBackend())
- .addProgramClasses(EmptySubC.class, C.class, Main.class)
+ .addProgramClasses(EmptySubC.class, C.class, D.class, Main.class)
.addProgramClassFileData(getClassBWithTransformedInvoked(holder))
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
- // The failures are very different from one back-end to another: verification error,
- // invalid invoke-super, segmentation fault, NoSuchMethod, etc.
- .assertFailure();
+ .assertSuccessWithOutputLines("Should not be called.");
}
private byte[] getClassBWithTransformedInvoked(Class<?> holder) throws IOException {
diff --git a/src/test/java/com/android/tools/r8/internal/proto/ChromeProtoRewritingTest.java b/src/test/java/com/android/tools/r8/internal/proto/ChromeProtoRewritingTest.java
index 318de07..12236fc 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/ChromeProtoRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/ChromeProtoRewritingTest.java
@@ -44,6 +44,8 @@
keepAllProtosRule(),
keepDynamicMethodSignatureRule(),
keepNewMessageInfoSignatureRule())
+ .addDontWarn("android.content.pm.IPackageManager")
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProtoShrinking(false)
.setMinApi(AndroidApiLevel.N)
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderOnlyReferencedFromDynamicMethodTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderOnlyReferencedFromDynamicMethodTest.java
index 6405047..d603cc1 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderOnlyReferencedFromDynamicMethodTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderOnlyReferencedFromDynamicMethodTest.java
@@ -49,6 +49,7 @@
.addKeepRuleFiles(PROTOBUF_LITE_PROGUARD_RULES)
.allowAccessModification()
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProtoShrinking()
.setMinApi(parameters.getApiLevel())
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 1375f54..868c061 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
@@ -74,6 +74,7 @@
.addKeepRuleFiles(PROTOBUF_LITE_PROGUARD_RULES)
.allowAccessModification()
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableInliningAnnotations()
.enableProtoShrinking()
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 d88e281..2d2e79f 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
@@ -87,6 +87,7 @@
.addNoHorizontalClassMergingRule(PARTIALLY_USED + "$Enum$1")
.allowAccessModification(allowAccessModification)
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProguardTestOptions()
.enableProtoShrinking()
@@ -356,6 +357,7 @@
.addKeepRules(keepDynamicMethodSignatureRule(), keepNewMessageInfoSignatureRule())
.allowAccessModification(allowAccessModification)
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProtoShrinking()
.minification(enableMinification)
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 429c340..a3c0705 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
@@ -60,6 +60,7 @@
.addKeepRuleFiles(PROTOBUF_LITE_PROGUARD_RULES)
.allowAccessModification(allowAccessModification)
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProtoShrinking()
.minification(enableMinification)
@@ -108,6 +109,7 @@
.addKeepRules(keepDynamicMethodSignatureRule(), keepNewMessageInfoSignatureRule())
.allowAccessModification(allowAccessModification)
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.enableProtoShrinking()
.minification(enableMinification)
diff --git a/src/test/java/com/android/tools/r8/internal/proto/YouTubeV1508ProtoRewritingTest.java b/src/test/java/com/android/tools/r8/internal/proto/YouTubeV1508ProtoRewritingTest.java
index 5596fc7..7cdab46 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/YouTubeV1508ProtoRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/YouTubeV1508ProtoRewritingTest.java
@@ -31,6 +31,7 @@
public YouTubeV1508ProtoRewritingTest(TestParameters parameters) {
super(15, 8);
+ parameters.assertNoneRuntime();
}
@Test
@@ -55,6 +56,7 @@
.addMainDexRuleFiles(getMainDexRuleFiles())
.allowCheckDiscardedErrors(true)
.allowDiagnosticMessages()
+ .allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
.setMinApi(AndroidApiLevel.H_MR2)
.compile()
diff --git a/src/test/java/com/android/tools/r8/ir/InlineTest.java b/src/test/java/com/android/tools/r8/ir/InlineTest.java
index cb48232..18f15fd 100644
--- a/src/test/java/com/android/tools/r8/ir/InlineTest.java
+++ b/src/test/java/com/android/tools/r8/ir/InlineTest.java
@@ -21,7 +21,6 @@
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.shaking.Enqueuer;
import com.android.tools.r8.shaking.EnqueuerFactory;
-import com.android.tools.r8.shaking.ProguardClassFilter;
import com.android.tools.r8.shaking.ProguardConfiguration;
import com.android.tools.r8.shaking.ProguardKeepRule;
import com.android.tools.r8.shaking.RootSetBuilder;
@@ -75,10 +74,9 @@
ImmutableList.of(ProguardKeepRule.defaultKeepAllRule(unused -> {})))
.run(executorService));
Timing timing = Timing.empty();
- Enqueuer enqueuer = EnqueuerFactory.createForInitialTreeShaking(appView, subtypingInfo);
- appView.setAppInfo(
- enqueuer.traceApplication(
- appView.rootSet(), ProguardClassFilter.empty(), executorService, timing));
+ Enqueuer enqueuer =
+ EnqueuerFactory.createForInitialTreeShaking(appView, executorService, subtypingInfo);
+ appView.setAppInfo(enqueuer.traceApplication(appView.rootSet(), executorService, timing));
return new TestApplication(appView, method, additionalCode);
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
index a2fe521..553a2f4 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
@@ -36,7 +36,6 @@
import it.unimi.dsi.fastutil.objects.Reference2IntMap;
import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -49,7 +48,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public FieldBitAccessInfoTest(TestParameters parameters) {
@@ -61,7 +60,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class)
.addKeepMainRule(TestClass.class)
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines(
@@ -93,7 +92,7 @@
clazz.forEachProgramMethod(
method -> {
IRCode code = method.buildIR(appView);
- fieldAccessAnalysis.recordFieldAccesses(code, feedback, new MethodProcessorMock());
+ fieldAccessAnalysis.recordFieldAccesses(code, feedback, new PrimaryMethodProcessorMock());
});
int bitsReadInBitField = feedback.bitsReadPerField.getInt(uniqueFieldByName(clazz, "bitField"));
@@ -116,7 +115,7 @@
}
}
- private AppView<AppInfoWithClassHierarchy> buildApp() throws IOException, ExecutionException {
+ private AppView<AppInfoWithClassHierarchy> buildApp() throws IOException {
DexItemFactory dexItemFactory = new DexItemFactory();
InternalOptions options = new InternalOptions(dexItemFactory, new Reporter());
options.programConsumer =
@@ -210,12 +209,7 @@
}
}
- static class MethodProcessorMock extends MethodProcessor {
-
- @Override
- public Phase getPhase() {
- return Phase.PRIMARY;
- }
+ static class PrimaryMethodProcessorMock extends MethodProcessor {
@Override
public boolean shouldApplyCodeRewritings(ProgramMethod method) {
@@ -223,6 +217,11 @@
}
@Override
+ public boolean isPrimaryMethodProcessor() {
+ return true;
+ }
+
+ @Override
public boolean isProcessedConcurrently(ProgramMethod method) {
return false;
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
index 6d3c6cb..e654b89 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
@@ -69,6 +69,7 @@
.addProgramClasses(A.class, ASub1.class, Box.class, TestClass.class)
.addKeepAllClassesRule()
.addOptionsModification(options -> options.testing.allowTypeErrors = allowTypeErrors)
+ .addDontWarn(ASub2.class)
.allowDiagnosticWarningMessages()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
index a4c9785..3a6f0e4 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.Argument;
@@ -33,6 +32,7 @@
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterFieldAccess;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterInvoke;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -63,7 +63,7 @@
boolean npeCaught,
BiConsumer<AppView<?>, IRCode> inspector)
throws Exception {
- AppView<? extends AppInfoWithClassHierarchy> appView = build(mainClass);
+ AppView<AppInfoWithLiveness> appView = build(mainClass);
CodeInspector codeInspector = new CodeInspector(appView.appInfo().app());
MethodSubject fooSubject = codeInspector.clazz(mainClass.getName()).method(signature);
IRCode irCode = fooSubject.buildIR();
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeElementWidthTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeElementWidthTest.java
index 304d344..c07c431 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeElementWidthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeElementWidthTest.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.graph.DexItemFactory;
-import com.google.common.collect.ImmutableSet;
import org.junit.Test;
public class TypeElementWidthTest extends TestBase {
@@ -78,7 +77,7 @@
DexItemFactory dexItemFactory = new DexItemFactory();
ClassTypeElement referenceType =
ClassTypeElement.create(
- dexItemFactory.objectType, Nullability.maybeNull(), ImmutableSet.of());
+ dexItemFactory.objectType, Nullability.maybeNull(), InterfaceCollection.empty());
assertFalse(referenceType.isSinglePrimitive());
assertFalse(referenceType.isWidePrimitive());
assertEquals(1, referenceType.requiredRegisters());
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
index 5cdd0ca..4f15b2d 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
@@ -20,6 +20,7 @@
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection.Builder;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -554,6 +555,14 @@
Nullability.bottom(), ReferenceTypeElement.getNull().asMeetWithNotNull().nullability());
}
+ private static InterfaceCollection itfs(DexType... types) {
+ Builder builder = InterfaceCollection.builder();
+ for (DexType type : types) {
+ builder.addInterface(type, true);
+ }
+ return builder.build();
+ }
+
@Test
public void testLeastUpperBoundOfInterfaces() {
DexType collection = factory.createType("Ljava/util/Collection;");
@@ -561,37 +570,32 @@
DexType list = factory.createType("Ljava/util/List;");
DexType serializable = factory.serializableType;
- Set<DexType> lub =
- computeLeastUpperBoundOfInterfaces(appView, ImmutableSet.of(set), ImmutableSet.of(list));
+ InterfaceCollection lub = computeLeastUpperBoundOfInterfaces(appView, itfs(set), itfs(list));
assertEquals(1, lub.size());
- assertTrue(lub.contains(collection));
- verifyViaPairwiseJoin(lub,
- ImmutableSet.of(set), ImmutableSet.of(list));
+ assertTrue(lub.containsKnownInterface(collection));
+ assertEquals(collection, lub.getSingleKnownInterface());
+ verifyViaPairwiseJoin(lub, ImmutableSet.of(set), ImmutableSet.of(list));
lub =
computeLeastUpperBoundOfInterfaces(
- appView, ImmutableSet.of(set, serializable), ImmutableSet.of(list, serializable));
+ appView, itfs(set, serializable), itfs(list, serializable));
assertEquals(2, lub.size());
- assertTrue(lub.contains(collection));
- assertTrue(lub.contains(serializable));
+ assertTrue(lub.containsKnownInterface(collection));
+ assertTrue(lub.containsKnownInterface(serializable));
verifyViaPairwiseJoin(lub,
ImmutableSet.of(set, serializable), ImmutableSet.of(list, serializable));
- lub =
- computeLeastUpperBoundOfInterfaces(
- appView, ImmutableSet.of(set), ImmutableSet.of(list, serializable));
+ lub = computeLeastUpperBoundOfInterfaces(appView, itfs(set), itfs(list, serializable));
assertEquals(1, lub.size());
- assertTrue(lub.contains(collection));
- assertFalse(lub.contains(serializable));
+ assertTrue(lub.containsKnownInterface(collection));
+ assertFalse(lub.containsKnownInterface(serializable));
verifyViaPairwiseJoin(lub,
ImmutableSet.of(set), ImmutableSet.of(list, serializable));
- lub =
- computeLeastUpperBoundOfInterfaces(
- appView, ImmutableSet.of(set, serializable), ImmutableSet.of(list));
+ lub = computeLeastUpperBoundOfInterfaces(appView, itfs(set, serializable), itfs(list));
assertEquals(1, lub.size());
- assertTrue(lub.contains(collection));
- assertFalse(lub.contains(serializable));
+ assertTrue(lub.containsKnownInterface(collection));
+ assertFalse(lub.containsKnownInterface(serializable));
verifyViaPairwiseJoin(lub,
ImmutableSet.of(set, serializable), ImmutableSet.of(list));
@@ -599,16 +603,14 @@
DexType wType = factory.createType("Ljava/lang/reflect/WildcardType;");
DexType pType = factory.createType("Ljava/lang/reflect/ParameterizedType;");
- lub =
- computeLeastUpperBoundOfInterfaces(appView, ImmutableSet.of(wType), ImmutableSet.of(pType));
+ lub = computeLeastUpperBoundOfInterfaces(appView, itfs(wType), itfs(pType));
assertEquals(1, lub.size());
- assertTrue(lub.contains(type));
+ assertTrue(lub.containsKnownInterface(type));
+ assertEquals(type, lub.getSingleKnownInterface());
verifyViaPairwiseJoin(lub,
ImmutableSet.of(wType), ImmutableSet.of(pType));
- lub =
- computeLeastUpperBoundOfInterfaces(
- appView, ImmutableSet.of(list, serializable), ImmutableSet.of(pType));
+ lub = computeLeastUpperBoundOfInterfaces(appView, itfs(list, serializable), itfs(pType));
assertEquals(0, lub.size());
verifyViaPairwiseJoin(lub,
ImmutableSet.of(list, serializable), ImmutableSet.of(pType));
@@ -621,41 +623,36 @@
DescriptorUtils.javaTypeToDescriptor(I3.class.getCanonicalName()));
DexType i4 = factory.createType(
DescriptorUtils.javaTypeToDescriptor(I4.class.getCanonicalName()));
- lub = computeLeastUpperBoundOfInterfaces(appView, ImmutableSet.of(i3), ImmutableSet.of(i4));
+ lub = computeLeastUpperBoundOfInterfaces(appView, itfs(i3), itfs(i4));
assertEquals(2, lub.size());
- assertTrue(lub.contains(i1));
- assertTrue(lub.contains(i2));
+ assertTrue(lub.containsKnownInterface(i1));
+ assertTrue(lub.containsKnownInterface(i2));
verifyViaPairwiseJoin(lub,
ImmutableSet.of(i3), ImmutableSet.of(i4));
}
- private void verifyViaPairwiseJoin(Set<DexType> lub, Set<DexType> s1, Set<DexType>s2) {
- ImmutableSet.Builder<DexType> builder = ImmutableSet.builder();
+ private void verifyViaPairwiseJoin(InterfaceCollection lub, Set<DexType> s1, Set<DexType> s2) {
+ InterfaceCollection.Builder builder = InterfaceCollection.builder();
for (DexType i1 : s1) {
for (DexType i2 : s2) {
- Set<DexType> lubPerPair =
- computeLeastUpperBoundOfInterfaces(appView, ImmutableSet.of(i1), ImmutableSet.of(i2));
- for (DexType lubInterface : lubPerPair) {
- builder.add(lubInterface);
- }
+ InterfaceCollection lubPerPair =
+ computeLeastUpperBoundOfInterfaces(
+ appView, InterfaceCollection.singleton(i1), InterfaceCollection.singleton(i2));
+ lubPerPair.forEach(builder::addInterface);
}
}
- Set<DexType> pairwiseJoin = builder.build();
- ImmutableSet.Builder<DexType> lubBuilder = ImmutableSet.builder();
- for (DexType itf : pairwiseJoin) {
- // If there is a strict sub interface of this interface, it is not the least element.
- if (pairwiseJoin.stream()
- .anyMatch(other -> appView.appInfo().isStrictSubtypeOf(other, itf))) {
- continue;
- }
- lubBuilder.add(itf);
- }
- Set<DexType> pairwiseLub = lubBuilder.build();
-
- assertEquals(pairwiseLub.size(), lub.size());
- for (DexType i : pairwiseLub) {
- assertTrue(lub.contains(i));
- }
+ InterfaceCollection pairwiseJoin = builder.build();
+ InterfaceCollection.Builder lubBuilder = InterfaceCollection.builder();
+ pairwiseJoin.forEach(
+ (itf, isKnown) -> {
+ // If there is a strict sub interface of this interface, it is not the least element.
+ if (!pairwiseJoin.anyMatch(
+ (other, ignoredOtherIsKnown) -> appView.appInfo().isStrictSubtypeOf(other, itf))) {
+ lubBuilder.addInterface(itf, isKnown);
+ }
+ });
+ InterfaceCollection pairwiseLub = lubBuilder.build();
+ assertEquals(pairwiseLub, lub);
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
index daa21f4..f5431bb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
@@ -9,7 +9,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.InstancePut;
@@ -22,6 +21,7 @@
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterInvoke;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterNullCheck;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -49,7 +49,7 @@
int expectedNumberOfNonNull,
Consumer<IRCode> testAugmentedIRCode)
throws Exception {
- AppView<? extends AppInfoWithClassHierarchy> appView = build(testClass);
+ AppView<AppInfoWithLiveness> appView = build(testClass);
CodeInspector codeInspector = new CodeInspector(appView.appInfo().app());
MethodSubject fooSubject = codeInspector.clazz(testClass.getName()).method(signature);
IRCode code = fooSubject.buildIR();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java
index 6b5f0cb..7d5e23e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java
@@ -5,13 +5,12 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
public abstract class NonNullTrackerTestBase extends TestBase {
- protected AppView<? extends AppInfoWithClassHierarchy> build(Class<?> mainClass)
- throws Exception {
- return computeAppViewWithSubtyping(buildAndroidApp(ToolHelper.getClassAsBytes(mainClass)));
+ protected AppView<AppInfoWithLiveness> build(Class<?> mainClass) throws Exception {
+ return computeAppViewWithLiveness(buildAndroidApp(ToolHelper.getClassAsBytes(mainClass)));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
index 14d7e6b..da19669 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
@@ -5,7 +5,9 @@
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ir.optimize.nonnull.FieldAccessTest;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterArrayAccess;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterFieldAccess;
@@ -32,10 +34,19 @@
}
private void testR8(Class<?> testClass, List<MethodSignature> signatures) throws Exception {
+ testR8(testClass, signatures, null);
+ }
+
+ private void testR8(
+ Class<?> testClass,
+ List<MethodSignature> signatures,
+ ThrowableConsumer<R8FullTestBuilder> configuration)
+ throws Exception {
CodeInspector codeInspector =
testForR8(Backend.DEX)
.addProgramClasses(testClass)
.addKeepRules("-keep class " + testClass.getCanonicalName() + " { *; }")
+ .apply(configuration)
.compile()
.inspector();
verifyAbsenceOfIf(codeInspector, testClass, signatures);
@@ -67,6 +78,9 @@
new String[]{FieldAccessTest.class.getCanonicalName()});
MethodSignature foo2 = new MethodSignature("foo2", "int",
new String[]{FieldAccessTest.class.getCanonicalName()});
- testR8(NonNullAfterFieldAccess.class, ImmutableList.of(foo, bar, foo2));
+ testR8(
+ NonNullAfterFieldAccess.class,
+ ImmutableList.of(foo, bar, foo2),
+ testBuilder -> testBuilder.addProgramClasses(FieldAccessTest.class));
}
}
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 87de375..19d7226 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
@@ -86,6 +86,7 @@
testForR8(backend)
.addInnerClasses(SubsumedCatchHandlerTest.class)
.addKeepMainRule(TestClass.class)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expected)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EffectivelyFinalFieldCanonicalizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EffectivelyFinalFieldCanonicalizationTest.java
index 4e73445..59eff5b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EffectivelyFinalFieldCanonicalizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/EffectivelyFinalFieldCanonicalizationTest.java
@@ -40,6 +40,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(EffectivelyFinalFieldCanonicalizationTest.class)
.addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastToUninstantiatedClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastToUninstantiatedClassTest.java
index aa385fd..895e6ab 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastToUninstantiatedClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastToUninstantiatedClassTest.java
@@ -25,8 +25,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- // TODO(b/172194277): Add support for synthetics when generating CF.
- return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public CastToUninstantiatedClassTest(TestParameters parameters) {
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 c9033f5..2922b90 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
@@ -58,6 +58,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(NonFinalFieldWithDefaultValueTest.class)
.addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
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 e0266bd..38bb02e 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
@@ -4,7 +4,6 @@
package com.android.tools.r8.ir.optimize.classinliner;
-import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.containsString;
@@ -322,8 +321,8 @@
Set<String> expectedTypes = Sets.newHashSet("java.lang.StringBuilder");
expectedTypes.addAll(
inspector.allClasses().stream()
+ .filter(FoundClassSubject::isSynthesizedJavaLambdaClass)
.map(FoundClassSubject::getFinalName)
- .filter(name -> name.contains(LAMBDA_CLASS_NAME_PREFIX))
.collect(Collectors.toList()));
assertEquals(expectedTypes, collectTypes(clazz.uniqueMethodWithName("testStatefulLambda")));
assertTrue(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ExtraMethodNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ExtraMethodNullTest.java
index 3ece2da..9890166 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ExtraMethodNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ExtraMethodNullTest.java
@@ -4,21 +4,36 @@
package com.android.tools.r8.ir.optimize.classinliner;
-import static org.hamcrest.CoreMatchers.containsString;
-import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class ExtraMethodNullTest extends TestBase {
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ExtraMethodNullTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
@Test
public void test() throws Exception {
- testForR8(Backend.DEX)
+ testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(One.class)
.addKeepMainRule(One.class)
- .run(One.class)
- .assertFailureWithErrorThatMatches(containsString("java.lang.NullPointerException"));
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), One.class)
+ .assertFailureWithErrorThatThrows(NullPointerException.class);
}
public static class One {
@@ -30,7 +45,6 @@
}
static class Other {
- @NeverInline
Object print(Object one) {
return one;
}
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 b21e168..be426b1 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
@@ -26,13 +26,15 @@
@Test
public void test() throws Throwable {
- R8TestCompileResult result = testForR8(Backend.CF)
- .setMode(CompilationMode.DEBUG)
- .addProgramClasses(TestInterface.class, IMPL, MAIN)
- .addKeepMainRule(MAIN)
- .addKeepRules(ImmutableList.of("-keepattributes SourceFile,LineNumberTable"))
- .noMinification()
- .compile();
+ R8TestCompileResult result =
+ testForR8(Backend.CF)
+ .setMode(CompilationMode.DEBUG)
+ .addProgramClasses(TestInterface.class, IMPL, MAIN)
+ .addKeepMainRule(MAIN)
+ .addKeepRules(ImmutableList.of("-keepattributes SourceFile,LineNumberTable"))
+ .enableNoVerticalClassMergingAnnotations()
+ .noMinification()
+ .compile();
CodeInspector inspector = result.inspector();
ClassSubject mainSubject = inspector.clazz(MAIN);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/fields/NonFinalFinalFieldTest.java b/src/test/java/com/android/tools/r8/ir/optimize/fields/NonFinalFinalFieldTest.java
index 292f74e..d8cdbc5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/fields/NonFinalFinalFieldTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/fields/NonFinalFinalFieldTest.java
@@ -49,6 +49,7 @@
.addProgramClasses(TestClass.class)
.addProgramClassFileData(getProgramClassFileData())
.addKeepMainRule(TestClass.class)
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java
index a8abf65..c4a0b9d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.naming.retrace.RetraceTestBase;
import com.android.tools.r8.naming.retrace.StackTrace;
@@ -46,6 +47,11 @@
}
@Override
+ public void configure(R8TestBuilder<?> builder) {
+ builder.enableInliningAnnotations();
+ }
+
+ @Override
public Class<?> getMainClass() {
return Main.class;
}
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 a3b0c4a..46727f2 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
@@ -10,6 +10,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ir.optimize.inliner.testclasses.InliningIntoVisibilityBridgeTestClasses;
@@ -47,10 +48,10 @@
.addInnerClasses(InliningIntoVisibilityBridgeTest.class)
.addInnerClasses(InliningIntoVisibilityBridgeTestClasses.class)
.addKeepMainRule(TestClass.class)
- .addKeepRules(
- neverInline
- ? ("-neverinline class " + getClassA().getTypeName() + " { method(); }")
- : "")
+ .addForceInliningAnnotations()
+ .addInliningAnnotations()
+ .applyIf(neverInline, R8TestBuilder::enableInliningAnnotations)
+ .applyIf(!neverInline, R8TestBuilder::enableForceInliningAnnotations)
.enableNoVerticalClassMergingAnnotations()
.enableProguardTestOptions()
.compile()
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 a0ed3e6..09bb71b 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
@@ -29,7 +29,8 @@
@Parameterized.Parameters(name = "{1}, invoke A.m(): {0}")
public static List<Object[]> data() {
- return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
public MultipleIndirectCallSitesTest(boolean invokeMethodOnA, TestParameters parameters) {
@@ -47,6 +48,7 @@
// kept, there is a single call site that invokes A.m(). However, this does not mean that
// A.m() has a single call site, so it should not allow inlining of A.m().
.addKeepRules(getKeepRules())
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(this::verifyInlining)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
index 09b0ae3..235aa07 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
@@ -26,7 +26,10 @@
@Parameters(name = "{0}")
public static TestParametersCollection params() {
- return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.K)
+ .build();
}
public Regress131349148(TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/InliningIntoVisibilityBridgeTestClasses.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/InliningIntoVisibilityBridgeTestClasses.java
index c8c60ae..54018ee 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/InliningIntoVisibilityBridgeTestClasses.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/InliningIntoVisibilityBridgeTestClasses.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.optimize.inliner.testclasses;
import com.android.tools.r8.ForceInline;
+import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
public class InliningIntoVisibilityBridgeTestClasses {
@@ -17,6 +18,7 @@
static class InliningIntoVisibilityBridgeTestClassA {
@ForceInline
+ @NeverInline
public static void method() {
System.out.println("Hello world");
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/ZipFileInstanceOfAutoCloseableTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/ZipFileInstanceOfAutoCloseableTest.java
new file mode 100644
index 0000000..b15cca9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/ZipFileInstanceOfAutoCloseableTest.java
@@ -0,0 +1,226 @@
+// 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.ir.optimize.instanceofremoval;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
+import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.file.Path;
+import java.util.jar.JarFile;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ZipFileInstanceOfAutoCloseableTest extends TestBase {
+
+ static final String EXPECTED_PRE_API_19 = StringUtils.lines("Not an AutoCloseable");
+ static final String EXPECTED_POST_API_19 = StringUtils.lines("Is an AutoCloseable");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ZipFileInstanceOfAutoCloseableTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private boolean runtimeZipFileIsCloseable() {
+ return parameters.isCfRuntime()
+ || parameters
+ .getRuntime()
+ .asDex()
+ .maxSupportedApiLevel()
+ .isGreaterThanOrEqualTo(AndroidApiLevel.K);
+ }
+
+ private String expectedOutput() {
+ return runtimeZipFileIsCloseable() ? EXPECTED_POST_API_19 : EXPECTED_PRE_API_19;
+ }
+
+ private Path getAndroidJar() {
+ // Always use an android jar later than API 19. Thus at compile-time ZipFile < Closeable.
+ return ToolHelper.getAndroidJar(AndroidApiLevel.LATEST);
+ }
+
+ private String getZipFile() throws IOException {
+ return ZipBuilder.builder(temp.newFile("file.zip").toPath())
+ .addBytes("entry", new byte[1])
+ .build()
+ .toString();
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ testForD8()
+ .addInnerClasses(ZipFileInstanceOfAutoCloseableTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .addLibraryFiles(getAndroidJar())
+ .run(parameters.getRuntime(), TestClass.class, getZipFile())
+ .assertSuccessWithOutput(expectedOutput());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ZipFileInstanceOfAutoCloseableTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .addLibraryFiles(getAndroidJar())
+ .run(parameters.getRuntime(), TestClass.class, getZipFile())
+ .assertSuccessWithOutput(expectedOutput());
+ }
+
+ @Test
+ public void testTypeStructure() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ // Set the min API and create the raw app.
+ InternalOptions options = new InternalOptions();
+ options.minApiLevel = parameters.getApiLevel().getLevel();
+ DirectMappedDexApplication application =
+ new ApplicationReader(
+ AndroidApp.builder()
+ .addProgramFiles(ToolHelper.getClassFileForTestClass(MyJarFileScanner.class))
+ .addLibraryFiles(getAndroidJar())
+ .build(),
+ options,
+ Timing.empty())
+ .read()
+ .toDirect();
+ AppView<AppInfoWithClassHierarchy> appView = AppView.createForR8(application);
+
+ // Type references.
+ DexType zipFileType = appView.dexItemFactory().createType("Ljava/util/zip/ZipFile;");
+ DexType closeableType = appView.dexItemFactory().createType("Ljava/io/Closeable;");
+ DexType autoCloseableType = appView.dexItemFactory().createType("Ljava/lang/AutoCloseable;");
+ DexType scannerType = appView.dexItemFactory().createType("Ljava/util/Scanner;");
+ DexType myJarFileChannel = buildType(MyJarFileScanner.class, appView.dexItemFactory());
+
+ // Read the computed interface types. Both the "type element" which is used in IR and the full
+ // computed dependencies.
+ ClassTypeElement zipFileTypeElement = makeTypeElement(appView, zipFileType);
+ {
+ InterfaceCollection directInterfaces = zipFileTypeElement.getInterfaces();
+ InterfaceCollection allInterfaces = appView.appInfo().implementedInterfaces(zipFileType);
+ if (zipFileHasCloseable()) {
+ // After API 19 / K the types are known and present.
+ assertEquals(closeableType, directInterfaces.getSingleKnownInterface());
+ assertTrue(allInterfaces.containsKnownInterface(closeableType));
+ assertTrue(allInterfaces.containsKnownInterface(autoCloseableType));
+ assertEquals(2, allInterfaces.size());
+ } else {
+ // The interfaces are still present due to the android jar for K, but they are marked
+ // unknown.
+ assertTrue(directInterfaces.contains(closeableType).isUnknown());
+ assertFalse(directInterfaces.containsKnownInterface(closeableType));
+ assertEquals(1, directInterfaces.size());
+ // Same for the collection of all interfaces. Since the
+ assertTrue(allInterfaces.contains(closeableType).isUnknown());
+ assertTrue(allInterfaces.contains(autoCloseableType).isUnknown());
+ assertFalse(allInterfaces.containsKnownInterface(closeableType));
+ assertFalse(allInterfaces.containsKnownInterface(autoCloseableType));
+ assertEquals(2, allInterfaces.size());
+ }
+ }
+
+ ClassTypeElement scannerTypeElement = makeTypeElement(appView, scannerType);
+ {
+ // Scanner implements Closable and Iterator on all APIs.
+ InterfaceCollection directInterfaces = scannerTypeElement.getInterfaces();
+ assertTrue(directInterfaces.containsKnownInterface(closeableType));
+ assertEquals(2, directInterfaces.size());
+
+ // Joining a type of known with a type of unknown should still be unknown.
+ ClassTypeElement joinLeft1 =
+ scannerTypeElement.join(zipFileTypeElement, appView).asClassType();
+ ClassTypeElement joinRight1 =
+ zipFileTypeElement.join(scannerTypeElement, appView).asClassType();
+ if (zipFileHasCloseable()) {
+ assertTrue(joinLeft1.getInterfaces().contains(closeableType).isTrue());
+ assertTrue(joinRight1.getInterfaces().contains(closeableType).isTrue());
+ } else {
+ assertTrue(joinLeft1.getInterfaces().contains(closeableType).isUnknown());
+ assertTrue(joinRight1.getInterfaces().contains(closeableType).isUnknown());
+ }
+ }
+
+ // Custom class derived from JarFile and Channel, thus it must implement closable.
+ ClassTypeElement myJarFileScannerTypeElement = makeTypeElement(appView, myJarFileChannel);
+
+ // Joining with Scanner will retain it as always Closeable.
+ ClassTypeElement joinWithScanner =
+ myJarFileScannerTypeElement.join(scannerTypeElement, appView).asClassType();
+ assertTrue(joinWithScanner.getInterfaces().contains(closeableType).isTrue());
+
+ // Joining with ZipFile will loose the assurance that it is Closeable.
+ ClassTypeElement joinWithZipFile =
+ myJarFileScannerTypeElement.join(zipFileTypeElement, appView).asClassType();
+ assertTrue(joinWithZipFile.getInterfaces().contains(closeableType).isPossiblyTrue());
+ assertEquals(
+ zipFileHasCloseable(), joinWithZipFile.getInterfaces().contains(closeableType).isTrue());
+ }
+
+ private boolean zipFileHasCloseable() {
+ return parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
+ }
+
+ private static ClassTypeElement makeTypeElement(
+ AppView<AppInfoWithClassHierarchy> appView, DexType type) {
+ return ClassTypeElement.create(type, Nullability.maybeNull(), appView);
+ }
+
+ static class MyJarFileScanner extends JarFile implements Channel {
+
+ public MyJarFileScanner(String name) throws IOException {
+ super(name);
+ }
+
+ @Override
+ public boolean isOpen() {
+ return false;
+ }
+ }
+
+ static class TestClass {
+
+ public static void foo(Object o) throws Exception {
+ if (o instanceof AutoCloseable) {
+ System.out.println("Is an AutoCloseable");
+ ((AutoCloseable) o).close();
+ } else {
+ System.out.println("Not an AutoCloseable");
+ }
+ }
+
+ public static void main(String[] args) throws Exception {
+ foo(new JarFile(args[0]));
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeNotNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeNotNullTest.java
new file mode 100644
index 0000000..fda891e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeNotNullTest.java
@@ -0,0 +1,130 @@
+// 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.ir.optimize.membervaluepropagation;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import 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;
+
+@RunWith(Parameterized.class)
+public class AssumeNotNullTest extends TestBase {
+
+ private final String flavor;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, flavor: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of("assumenosideeffects", "assumevalues"),
+ getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ public AssumeNotNullTest(String flavor, TestParameters parameters) {
+ this.flavor = flavor;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addKeepRules(
+ "-" + flavor + " class " + Factory.class.getTypeName() + " {",
+ " java.lang.Object create() return 1;",
+ "}",
+ "-" + flavor + " class " + Singleton.class.getTypeName() + " {",
+ " java.lang.Object INSTANCE return 1;",
+ "}")
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(
+ inspector -> {
+ MethodSubject mainMethodSubject = inspector.clazz(Main.class).mainMethod();
+ assertThat(mainMethodSubject, isPresent());
+ if (flavor.equals("assumenosideeffects")) {
+ // With -assumenosideeffects, the method should become empty.
+ assertTrue(
+ mainMethodSubject
+ .streamInstructions()
+ .allMatch(InstructionSubject::isReturnVoid));
+ } else {
+ // With -assumevalues, the Singleton.INSTANCE access should remain along with the
+ // Factory.create() invoke.
+ ClassSubject factoryClassSubject = inspector.clazz(Factory.class);
+ assertThat(factoryClassSubject, isPresent());
+
+ ClassSubject singletonClassSubject = inspector.clazz(Singleton.class);
+ assertThat(singletonClassSubject, isPresent());
+
+ assertEquals(
+ 2,
+ mainMethodSubject
+ .streamInstructions()
+ .filter(
+ instruction -> instruction.isFieldAccess() || instruction.isInvoke())
+ .count());
+ assertTrue(
+ mainMethodSubject
+ .streamInstructions()
+ .anyMatch(
+ instruction ->
+ instruction.isStaticGet()
+ && instruction.getField().getHolderType()
+ == singletonClassSubject.getDexProgramClass().getType()));
+ assertTrue(
+ mainMethodSubject
+ .streamInstructions()
+ .filter(InstructionSubject::isInvoke)
+ .anyMatch(
+ instruction ->
+ instruction.getMethod().getHolderType()
+ == factoryClassSubject.getDexProgramClass().getType()));
+ }
+ })
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithEmptyOutput();
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ if (Singleton.INSTANCE == null) {
+ System.out.println("Foo");
+ }
+ if (Factory.create() == null) {
+ System.out.println("Bar");
+ }
+ }
+ }
+
+ static class Factory {
+
+ @NeverInline
+ public static Object create() {
+ return System.currentTimeMillis() > 0 ? new Object() : null;
+ }
+ }
+
+ static class Singleton {
+
+ public static Object INSTANCE = System.currentTimeMillis() > 0 ? new Object() : null;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B143686595.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B143686595.java
index 036bde7..4f95f4d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B143686595.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/B143686595.java
@@ -39,6 +39,7 @@
.addProgramClasses(TestClass.class)
.addClasspathClasses(I.class)
.addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(libraryResult.writeToZip())
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 d2b739e..6c7cf37 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
@@ -40,6 +40,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InstanceFieldValuePropagationWithMultipleInstanceInitializersTest.class)
.addKeepMainRule(TestClass.class)
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
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 ec4c859..c0267f2 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
@@ -50,6 +50,7 @@
options.outline.minSize = 2;
})
.enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
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 3e28157..d1d5f1f 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.ForceInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.ListUtils;
@@ -218,6 +219,8 @@
testForR8(parameters.getBackend())
.setMode(mode)
.addInnerClasses(GetClassTest.class)
+ .addForceInliningAnnotations()
+ .applyIf(mode == CompilationMode.RELEASE, R8TestBuilder::enableForceInliningAnnotations)
.enableInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.addKeepMainRule(MAIN)
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 a9a5c6f..81612ee 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
@@ -214,6 +214,7 @@
R8TestRunResult result =
testForR8(parameters.getBackend())
.addProgramFiles(classPaths)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep class **.ClassGetSimpleName*")
@@ -243,6 +244,7 @@
.addKeepRules("-keep,allowobfuscation class **.Outer*")
.addKeepAttributes("InnerClasses", "EnclosingMethod")
.addKeepRules("-printmapping " + createNewMappingPath().toAbsolutePath().toString())
+ .enableForceInliningAnnotations()
.minification(enableMinification)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(this::configure)
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 9ee6ad7..6e91c38 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
@@ -116,6 +116,7 @@
.addKeepMainRule(main)
.addKeepAttributes("InnerClasses", "EnclosingMethod")
.addOptionsModification(this::configure)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), main)
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
index 59c3d5c..7924a77 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
@@ -96,6 +96,7 @@
R8TestRunResult result =
testForR8(parameters.getBackend())
.addProgramClasses(MAIN)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(MAIN)
.setMinApi(parameters.getApiLevel())
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 7d68bda..2e1709c 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
@@ -111,6 +111,7 @@
SingleTestRunResult<?> result =
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(MAIN)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
.addKeepMainRule(MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonConstIdTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonConstIdTest.java
new file mode 100644
index 0000000..c993353
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/StringSwitchWitNonConstIdTest.java
@@ -0,0 +1,106 @@
+// 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.ir.optimize.switches;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class StringSwitchWitNonConstIdTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public StringSwitchWitNonConstIdTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ testForD8()
+ .addProgramClasses(Main.class)
+ .release()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Foo", "Bar", "Baz", "Qux");
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Main.class)
+ .addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
+ .release()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Foo", "Bar", "Baz", "Qux");
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ test("Foo");
+ test("Bar");
+ test("Baz");
+ test("Qux");
+ }
+
+ @NeverInline
+ static void test(String str) {
+ int hashCode = str.hashCode();
+ int id = 0;
+ int foo = one();
+ switch (hashCode) {
+ case 70822: // "Foo".hashCode()
+ if (str.equals("Foo")) {
+ id = foo;
+ }
+ break;
+ case 66547: // "Bar".hashCode()
+ if (str.equals("Bar")) {
+ id = 2;
+ }
+ break;
+ case 66555: // "Baz".hashCode()
+ if (str.equals("Baz")) {
+ id = 3;
+ }
+ break;
+ }
+ switch (id) {
+ case 1:
+ System.out.println("Foo");
+ break;
+ case 2:
+ System.out.println("Bar");
+ break;
+ case 3:
+ System.out.println("Baz");
+ break;
+ default:
+ System.out.println("Qux");
+ break;
+ }
+ }
+
+ @NeverInline
+ static int one() {
+ return 1;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidInitTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidInitTest.java
index c8d8086..cb50223 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidInitTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidInitTest.java
@@ -35,6 +35,7 @@
testForR8(parameters.getBackend())
.addKeepMainRule(Main.class)
.enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
.addInnerClasses(SwitchMapInvalidInitTest.class)
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidOrdinalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidOrdinalTest.java
index a779afb..8c84a76 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidOrdinalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/switches/SwitchMapInvalidOrdinalTest.java
@@ -45,6 +45,7 @@
+ "com.android.tools.r8.ir.optimize.switches.SwitchMapInvalidOrdinalTest$MyEnum {"
+ " static <fields>; }")
.addInnerClasses(SwitchMapInvalidOrdinalTest.class)
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizationsTemplates.java b/src/test/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizationsTemplates.java
index 8f7c579..c1b1f8b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizationsTemplates.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/templates/CfUtilityMethodsForCodeOptimizationsTemplates.java
@@ -17,4 +17,12 @@
throw new ClassCastException();
}
}
+
+ public static IncompatibleClassChangeError throwIncompatibleClassChangeError() {
+ throw new IncompatibleClassChangeError();
+ }
+
+ public static NoSuchMethodError throwNoSuchMethodError() {
+ throw new NoSuchMethodError();
+ }
}
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 035ab54..c6dfe83 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
@@ -54,6 +54,7 @@
public void test() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(UninstantiatedAnnotatedArgumentsTest.class)
+ .addConstantArgumentAnnotations()
.addKeepMainRule(TestClass.class)
.addKeepClassRules(Instantiated.class, Uninstantiated.class)
.addKeepAttributes("RuntimeVisibleParameterAnnotations")
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 09c0de7..bd1b805 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
@@ -52,6 +52,7 @@
public void test() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(UnusedAnnotatedArgumentsTest.class)
+ .addUnusedArgumentAnnotations()
.addKeepMainRule(TestClass.class)
.addKeepClassRules(Used.class, Unused.class)
.addKeepAttributes("RuntimeVisibleParameterAnnotations")
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalPackageBoundaryTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalPackageBoundaryTest.java
new file mode 100644
index 0000000..9c4046d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalPackageBoundaryTest.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.unusedinterfaces;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ir.optimize.unusedinterfaces.testclasses.UnusedInterfaceRemovalPackageBoundaryTestClasses;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class UnusedInterfaceRemovalPackageBoundaryTest extends TestBase {
+
+ private static final Class<?> I_CLASS = UnusedInterfaceRemovalPackageBoundaryTestClasses.getI();
+ private static final Class<?> J_CLASS = UnusedInterfaceRemovalPackageBoundaryTestClasses.J.class;
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public UnusedInterfaceRemovalPackageBoundaryTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass(), UnusedInterfaceRemovalPackageBoundaryTestClasses.class)
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassRules(I_CLASS)
+ .enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .noMinification()
+ .compile()
+ .inspect(
+ inspector -> {
+ ClassSubject iClassSubject = inspector.clazz(I_CLASS);
+ assertThat(iClassSubject, isPresent());
+
+ ClassSubject jClassSubject = inspector.clazz(J_CLASS);
+ assertThat(jClassSubject, isPresent());
+
+ ClassSubject kClassSubject = inspector.clazz(K.class);
+ assertThat(kClassSubject, isAbsent());
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ assertEquals(1, aClassSubject.getDexProgramClass().getInterfaces().size());
+ assertEquals(
+ jClassSubject.getDexProgramClass().getType(),
+ aClassSubject.getDexProgramClass().getInterfaces().get(0));
+ })
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("A");
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new A();
+ }
+ }
+
+ @NoVerticalClassMerging
+ interface K extends UnusedInterfaceRemovalPackageBoundaryTestClasses.J {}
+
+ @NeverClassInline
+ static class A implements K {
+
+ A() {
+ System.out.println("A");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/testclasses/UnusedInterfaceRemovalPackageBoundaryTestClasses.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/testclasses/UnusedInterfaceRemovalPackageBoundaryTestClasses.java
new file mode 100644
index 0000000..0b623b2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/testclasses/UnusedInterfaceRemovalPackageBoundaryTestClasses.java
@@ -0,0 +1,20 @@
+// 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.ir.optimize.unusedinterfaces.testclasses;
+
+import com.android.tools.r8.NoVerticalClassMerging;
+
+public class UnusedInterfaceRemovalPackageBoundaryTestClasses {
+
+ @NoVerticalClassMerging
+ interface I {}
+
+ @NoVerticalClassMerging
+ public interface J extends I {}
+
+ public static Class<?> getI() {
+ return I.class;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
index 8d01a11..105008c 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
@@ -99,6 +99,17 @@
}
@Override
+ public void replaceCurrentInstructionWithThrow(
+ AppView<?> appView,
+ IRCode code,
+ ListIterator<BasicBlock> blockIterator,
+ Value exceptionValue,
+ Set<BasicBlock> blocksToRemove,
+ Set<Value> affectedValues) {
+ throw new Unimplemented();
+ }
+
+ @Override
public void replaceCurrentInstructionWithThrowNull(
AppView<? extends AppInfoWithClassHierarchy> appView,
IRCode code,
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index 293caa8..e4622be 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -16,6 +16,7 @@
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.code.NewInstance;
@@ -90,6 +91,7 @@
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
.addKeepRules("-neverinline class * { void test*State*(...); }")
+ .addDontWarnJetBrainsNotNullAnnotation()
.noClassInlining())
.inspect(
inspector -> {
@@ -110,7 +112,8 @@
testBuilder ->
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
- .addKeepRules("-neverinline class * { void test*State*(...); }"))
+ .addKeepRules("-neverinline class * { void test*State*(...); }")
+ .addDontWarnJetBrainsNotNullAnnotation())
.inspect(
inspector -> {
Predicate<DexType> lambdaCheck = createLambdaCheck(inspector);
@@ -156,6 +159,7 @@
"-neverinline class * { void test*State*(...); }",
"-neverinline class * { void testBigExtraMethod(...); }",
"-neverinline class * { void testBigExtraMethodReturningLambda(...); }")
+ .addDontWarnJetBrainsAnnotations()
.noClassInlining())
.inspect(
inspector -> {
@@ -197,9 +201,10 @@
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
.addKeepRules(
- "-neverinline class * { void test*State*(...); }",
- "-neverinline class * { void testBigExtraMethod(...); }",
- "-neverinline class * { void testBigExtraMethodReturningLambda(...); }"))
+ "-neverinline class * { void test*State*(...); }",
+ "-neverinline class * { void testBigExtraMethod(...); }",
+ "-neverinline class * { void testBigExtraMethodReturningLambda(...); }")
+ .addDontWarnJetBrainsAnnotations())
.inspect(
inspector -> {
Predicate<DexType> lambdaCheck = createLambdaCheck(inspector);
@@ -280,7 +285,10 @@
public void testDataClass() throws Exception {
assumeTrue("Only work with -allowaccessmodification", allowAccessModification);
final String mainClassName = "class_inliner_data_class.MainKt";
- runTestWithDefaults("class_inliner_data_class", mainClassName)
+ runTestWithDefaults(
+ "class_inliner_data_class",
+ mainClassName,
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
.inspect(
inspector -> {
ClassSubject clazz = inspector.clazz(mainClassName);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
index ec1793d..e5d0d09 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
@@ -74,6 +74,10 @@
return runTest(
folder,
mainClass,
- testBuilder -> testBuilder.noClassInlining().noClassStaticizing(noClassStaticizing));
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .noClassInlining()
+ .noClassStaticizing(noClassStaticizing));
}
}
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 c683b1a..eb1ca57 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -58,6 +58,7 @@
StringUtils.lines(
"-keepclasseswithmembers class " + MAIN + "{", " public static *** *(...);", "}"))
.allowAccessModification(allowAccessModification)
+ .addDontWarnJetBrainsNotNullAnnotation()
.noMinification()
.setMinApi(parameters.getRuntime())
.compile()
@@ -102,6 +103,7 @@
"-keepclasseswithmembers class " + MAIN + "{",
" public static *** " + methodName + "(...);",
"}"))
+ .addDontWarnJetBrainsNotNullAnnotation()
.allowAccessModification(allowAccessModification)
.noMinification()
.setMinApi(parameters.getRuntime())
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 b59d98c..5e25b92 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -10,6 +10,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -36,7 +37,10 @@
@Test
public void testMergingKStyleLambdasAfterUnusedArgumentRemoval() throws Exception {
final String mainClassName = "unused_arg_in_lambdas_kstyle.MainKt";
- runTest("unused_arg_in_lambdas_kstyle", mainClassName)
+ runTest(
+ "unused_arg_in_lambdas_kstyle",
+ mainClassName,
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
.inspect(
inspector ->
inspector.forAllClasses(
@@ -57,7 +61,10 @@
@Test
public void testMergingJStyleLambdasAfterUnusedArgumentRemoval() throws Exception {
final String mainClassName = "unused_arg_in_lambdas_jstyle.MainKt";
- runTest("unused_arg_in_lambdas_jstyle", mainClassName)
+ runTest(
+ "unused_arg_in_lambdas_jstyle",
+ mainClassName,
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
.inspect(
inspector ->
inspector.forAllClasses(
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 c358325..6a8e196 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -11,6 +11,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -45,7 +46,10 @@
public void b110196118() throws Exception {
final String mainClassName = "unused_singleton.MainKt";
final String moduleName = "unused_singleton.TestModule";
- runTest("unused_singleton", mainClassName)
+ runTest(
+ "unused_singleton",
+ mainClassName,
+ TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation)
.inspect(
inspector -> {
ClassSubject main = inspector.clazz(mainClassName);
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
index e90a8b6..3137d61 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
@@ -9,11 +9,11 @@
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -38,17 +38,11 @@
this.parameters = parameters;
}
- private void test(Collection<String> rules) throws Exception {
- test(rules, null);
- }
-
- private void test(
- Collection<String> rules, ThrowableConsumer<R8FullTestBuilder> consumer) throws Exception {
+ private void test(ThrowableConsumer<R8FullTestBuilder> consumer) throws Exception {
testForR8(parameters.getBackend())
.addLibraryFiles(
ToolHelper.getMostRecentAndroidJar(), ToolHelper.getKotlinStdlibJar(kotlinc))
.addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinc))
- .addKeepRules(rules)
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
@@ -58,54 +52,61 @@
@Test
public void testAsIs() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontoptimize", "-dontobfuscate"));
+ test(
+ builder ->
+ builder.addDontWarnJetBrains().noMinification().noOptimization().noTreeShaking());
}
@Test
public void testDontShrinkAndDontOptimize() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontoptimize"));
+ test(builder -> builder.addDontWarnJetBrains().noOptimization().noTreeShaking());
}
@Test
public void testDontShrinkAndDontOptimizeDifferently() throws Exception {
- test(
- ImmutableList.of("-keep,allowobfuscation class **.*KClasses*"),
- tb -> {
- tb.noTreeShaking();
- tb.addOptionsModification(o -> {
- // Randomly choose a couple of optimizations.
- o.enableVerticalClassMerging = false;
- o.enableClassStaticizer = false;
- o.outline.enabled = false;
- });
- });
+ test(
+ builder ->
+ builder
+ .addKeepRules("-keep,allowobfuscation class **.*KClasses*")
+ .addDontWarnJetBrains()
+ .noTreeShaking()
+ .addOptionsModification(
+ o -> {
+ // Randomly choose a couple of optimizations.
+ o.enableVerticalClassMerging = false;
+ o.enableClassStaticizer = false;
+ o.outline.enabled = false;
+ }));
}
@Test
public void testDontShrinkAndDontObfuscate() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontobfuscate"));
+ test(builder -> builder.addDontWarnJetBrains().noMinification().noTreeShaking());
}
@Test
public void testDontShrink() throws Exception {
- test(ImmutableList.of("-dontshrink"));
+ test(builder -> builder.addDontWarnJetBrains().noTreeShaking());
}
@Test
public void testDontShrinkDifferently() throws Exception {
test(
- ImmutableList.of("-keep,allowobfuscation class **.*KClasses*"),
- tb -> tb.noTreeShaking());
+ builder ->
+ builder
+ .addKeepRules("-keep,allowobfuscation class **.*KClasses*")
+ .addDontWarnJetBrains()
+ .noTreeShaking());
}
@Test
public void testDontOptimize() throws Exception {
- test(ImmutableList.of("-dontoptimize"));
+ test(TestShrinkerBuilder::noOptimization);
}
@Test
public void testDontObfuscate() throws Exception {
- test(ImmutableList.of("-dontobfuscate"));
+ test(TestShrinkerBuilder::noMinification);
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
index 7b3fd69..7166aed 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
@@ -37,13 +38,12 @@
this.parameters = parameters;
}
- private void test(Collection<String> rules, boolean expectInvalidFoo) throws Exception {
- test(rules, expectInvalidFoo, null);
+ private void test(Collection<String> rules) throws Exception {
+ test(rules, null);
}
private void test(
Collection<String> rules,
- boolean expectInvalidDebugInfo,
ThrowableConsumer<R8FullTestBuilder> consumer)
throws Exception {
testForR8(parameters.getBackend())
@@ -58,56 +58,60 @@
@Test
public void testAsIs() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontoptimize", "-dontobfuscate"), true);
+ test(
+ ImmutableList.of("-dontshrink", "-dontoptimize", "-dontobfuscate"),
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
}
@Test
public void testDontShrinkAndDontOptimize() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontoptimize"), true);
+ test(
+ ImmutableList.of("-dontshrink", "-dontoptimize"),
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
}
@Test
public void testDontShrinkAndDontOptimizeDifferently() throws Exception {
test(
ImmutableList.of("-keep,allowobfuscation class **.*Exception*"),
- true,
- tb -> {
- tb.noTreeShaking();
- tb.addOptionsModification(
- o -> {
- // Randomly choose a couple of optimizations.
- o.enableClassInlining = false;
- o.enableLambdaMerging = false;
- o.enableValuePropagation = false;
- });
- });
+ tb ->
+ tb.addDontWarnJetBrainsAnnotations()
+ .noTreeShaking()
+ .addOptionsModification(
+ o -> {
+ // Randomly choose a couple of optimizations.
+ o.enableClassInlining = false;
+ o.enableLambdaMerging = false;
+ o.enableValuePropagation = false;
+ }));
}
@Test
public void testDontShrinkAndDontObfuscate() throws Exception {
- test(ImmutableList.of("-dontshrink", "-dontobfuscate"), true);
+ test(
+ ImmutableList.of("-dontshrink", "-dontobfuscate"),
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
}
@Test
public void testDontShrink() throws Exception {
- test(ImmutableList.of("-dontshrink"), true);
+ test(ImmutableList.of("-dontshrink"), TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
}
@Test
public void testDontShrinkDifferently() throws Exception {
test(
ImmutableList.of("-keep,allowobfuscation class **.*Exception*"),
- true,
- tb -> tb.noTreeShaking());
+ tb -> tb.addDontWarnJetBrainsAnnotations().noTreeShaking());
}
@Test
public void testDontOptimize() throws Exception {
- test(ImmutableList.of("-dontoptimize"), false);
+ test(ImmutableList.of("-dontoptimize"));
}
@Test
public void testDontObfuscate() throws Exception {
- test(ImmutableList.of("-dontobfuscate"), false);
+ test(ImmutableList.of("-dontobfuscate"));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index cd5d8b1..882bc22 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.ToolHelper.ProcessResult;
@@ -83,7 +84,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePrimitiveProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -116,7 +120,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePrivateProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -151,7 +158,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_useInternalProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -185,7 +195,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePublicProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -219,7 +232,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_usePrivateLateInitProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ builder -> builder.addDontWarnJetBrainsAnnotations().noClassStaticizing())
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -252,7 +268,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_useInternalLateInitProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -281,7 +300,10 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_usePublicLateInitProp");
- runTest(PROPERTIES_PACKAGE_NAME, mainClass)
+ runTest(
+ PROPERTIES_PACKAGE_NAME,
+ mainClass,
+ TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -359,7 +381,7 @@
String mainClass =
addMainToClasspath(
"accessors.PropertyAccessorForInnerClassKt", "noUseOfPropertyAccessorFromInnerClass");
- runTest("accessors", mainClass)
+ runTest("accessors", mainClass, TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation)
.inspect(
inspector -> {
// Class is removed because the instantiation of the inner class has no side effects.
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index ef13161..3faf486 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -66,7 +66,10 @@
"dataclass",
mainClassName,
testBuilder ->
- testBuilder.addKeepRules(extraRules).addOptionsModification(disableClassInliner))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
ClassSubject dataClass = checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
@@ -107,7 +110,10 @@
"dataclass",
mainClassName,
testBuilder ->
- testBuilder.addKeepRules(extraRules).addOptionsModification(disableClassInliner))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
ClassSubject dataClass = checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
@@ -147,7 +153,10 @@
"dataclass",
mainClassName,
testBuilder ->
- testBuilder.addKeepRules(extraRules).addOptionsModification(disableClassInliner))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
ClassSubject dataClass = checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
@@ -187,7 +196,10 @@
"dataclass",
mainClassName,
testBuilder ->
- testBuilder.addKeepRules(extraRules).addOptionsModification(disableClassInliner))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
ClassSubject dataClass = checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
@@ -207,7 +219,10 @@
"dataclass",
mainClassName,
testBuilder ->
- testBuilder.addKeepRules(extraRules).addOptionsModification(disableClassInliner))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
ClassSubject dataClass = checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
index ea12c12..934ee16 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
@@ -47,7 +47,10 @@
"intrinsics",
"intrinsics.IntrinsicsKt",
testBuilder ->
- testBuilder.addKeepRules(extraRules).noHorizontalClassMerging(Intrinsics.class))
+ testBuilder
+ .addKeepRules(extraRules)
+ .addDontWarnJetBrainsAnnotations()
+ .noHorizontalClassMerging(Intrinsics.class))
.inspect(
inspector -> {
ClassSubject intrinsicsClass =
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index e04585c..d6d2477 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -113,7 +113,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
checkClassIsRemoved(inspector, MUTABLE_PROPERTY_CLASS.getClassName());
@@ -127,7 +130,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -156,7 +162,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -184,7 +193,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -212,7 +224,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -240,7 +255,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -283,7 +301,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -310,7 +331,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -335,7 +359,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -358,7 +385,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject classSubject =
@@ -426,7 +456,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -459,7 +492,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -498,7 +534,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -531,7 +570,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -566,7 +608,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -603,7 +648,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -631,7 +679,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -659,7 +710,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -697,7 +751,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -729,7 +786,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -768,7 +828,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -807,7 +870,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -839,7 +905,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -865,7 +934,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -891,7 +963,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -922,7 +997,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -953,7 +1031,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -986,7 +1067,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -1018,7 +1102,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject fileClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -1049,7 +1136,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
@@ -1077,7 +1167,10 @@
runTest(
PACKAGE_NAME,
mainClass,
- testBuilder -> testBuilder.addOptionsModification(disableAggressiveClassOptimizations))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
ClassSubject objectClass = checkClassIsKept(inspector, testedClass.getClassName());
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 70fd115..64e3a80 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -43,7 +43,10 @@
final String mainClassName = ex1.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
+ runTest(
+ FOLDER,
+ mainClassName,
+ testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex1.getClassName());
@@ -67,7 +70,10 @@
final String mainClassName = ex2.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
+ runTest(
+ FOLDER,
+ mainClassName,
+ testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex2.getClassName());
@@ -91,7 +97,10 @@
final String mainClassName = ex3.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
+ runTest(
+ FOLDER,
+ mainClassName,
+ testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex3.getClassName());
diff --git a/src/test/java/com/android/tools/r8/kotlin/TestKotlinDataClass.java b/src/test/java/com/android/tools/r8/kotlin/TestKotlinDataClass.java
index 62cda72..0426d41 100644
--- a/src/test/java/com/android/tools/r8/kotlin/TestKotlinDataClass.java
+++ b/src/test/java/com/android/tools/r8/kotlin/TestKotlinDataClass.java
@@ -36,18 +36,20 @@
}
public MemberNaming.MethodSignature getCopySignature() {
- List<String> propertiesTypes = properties.values().stream()
- .sorted(Comparator.comparingInt(p -> p.getIndex()))
- .map(p -> p.getType())
- .collect(Collectors.toList());
+ List<String> propertiesTypes =
+ properties.values().stream()
+ .sorted(Comparator.comparingInt(KotlinProperty::getIndex))
+ .map(KotlinProperty::getType)
+ .collect(Collectors.toList());
return new MemberNaming.MethodSignature("copy", className, propertiesTypes);
}
public MemberNaming.MethodSignature getCopyDefaultSignature() {
- List<String> propertiesTypes = properties.values().stream()
- .sorted(Comparator.comparingInt(p -> p.getIndex()))
- .map(p -> p.getType())
- .collect(Collectors.toList());
+ List<String> propertiesTypes =
+ properties.values().stream()
+ .sorted(Comparator.comparingInt(KotlinProperty::getIndex))
+ .map(KotlinProperty::getType)
+ .collect(Collectors.toList());
List<String> copyDefaultParameterTypes = new ArrayList<>(propertiesTypes.size() + 3);
copyDefaultParameterTypes.add(className);
diff --git a/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
index 9ae5aed..4a05b76 100644
--- a/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
@@ -80,10 +80,14 @@
.addKeepAllAttributes()
// The BASE_LIBRARY contains proguard rules that do not match.
.allowUnusedProguardConfigurationRules()
- .addKeepRules(
- "-dontwarn reactor.blockhound.integration.BlockHoundIntegration",
- "-dontwarn org.junit.runners.model.Statement",
- "-dontwarn org.junit.rules.TestRule")
+ .addDontWarn(
+ "edu.umd.cs.findbugs.annotations.SuppressFBWarnings",
+ "reactor.blockhound.BlockHound$Builder",
+ "reactor.blockhound.integration.BlockHoundIntegration",
+ "org.junit.rules.TestRule",
+ "org.junit.runner.Description",
+ "org.junit.runners.model.Statement",
+ "org.junit.runners.model.TestTimedOutException")
.compile()
.inspect(inspector -> assertEqualMetadata(new CodeInspector(BASE_LIBRARY), inspector))
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
index b9baae8..aea188c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
@@ -55,6 +55,7 @@
.addHorizontallyMergedLambdaClassesInspector(
inspector -> inspector.assertMerged(Lambda1.class, Lambda2.class))
.addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(EnumUnboxingCandidate.class))
+ .addDontWarnJetBrainsNotNullAnnotation()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
index 1b6d4c0..4f78df2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
@@ -57,6 +57,7 @@
.addLibraryFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
.addProgramFiles(ktClasses)
.addKeepMainRule("**.B143165163Kt")
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
@@ -80,6 +81,7 @@
.addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
.addProgramFiles(ktClasses)
.addKeepMainRule("**.B143165163Kt")
+ .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
index e7c4762..9cee958 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
@@ -45,6 +45,7 @@
.setMode(CompilationMode.DEBUG)
.addProgramFiles(compiledJars.getForConfiguration(kotlinc, KotlinTargetVersion.JAVA_6))
.addProgramFiles(getJavaJarFile(FOLDER))
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(MAIN_CLASS)
.allowDiagnosticWarningMessages()
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
index b9e0546..5a23bd3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
@@ -306,6 +306,7 @@
.addKeepRules(
"-keepunusedarguments class * extends kotlin.jvm.internal.Lambda {"
+ " invoke(int, short); }")
+ .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(this::configure))
.inspect(
inspector -> {
@@ -356,7 +357,10 @@
runTest(
"lambdas_kstyle_captures",
mainClassName,
- testBuilder -> testBuilder.addOptionsModification(this::configure))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(this::configure))
.inspect(
inspector -> {
if (enableUnusedInterfaceRemoval) {
@@ -390,7 +394,10 @@
runTest(
"lambdas_kstyle_generics",
mainClassName,
- testBuilder -> testBuilder.addOptionsModification(this::configure))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(this::configure))
.inspect(
inspector -> {
if (enableUnusedInterfaceRemoval) {
@@ -422,6 +429,7 @@
mainClassName,
testBuilder ->
testBuilder
+ .addDontWarnJetBrainsAnnotations()
.addKeepAttributeInnerClassesAndEnclosingMethod()
.addOptionsModification(this::configure))
.inspect(
@@ -458,6 +466,7 @@
// KEEP_SIGNATURE_INNER_ENCLOSING,
testBuilder ->
testBuilder
+ .addDontWarnJetBrainsAnnotations()
.addKeepAttributeInnerClassesAndEnclosingMethod()
.addKeepAttributeSignature()
.addOptionsModification(this::configure))
@@ -494,7 +503,10 @@
runTest(
"lambdas_jstyle_trivial",
mainClassName,
- testBuilder -> testBuilder.addOptionsModification(this::configure))
+ testBuilder ->
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(this::configure))
.inspect(
inspector -> {
Verifier verifier = new Verifier(inspector);
@@ -545,7 +557,10 @@
"lambdas_singleton",
mainClassName,
testBuilder ->
- testBuilder.addOptionsModification(this::configure).noHorizontalClassMerging())
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(this::configure)
+ .noHorizontalClassMerging())
.inspect(
inspector -> {
Verifier verifier = new Verifier(inspector);
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
index b1b38b9..b8fb366 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
@@ -35,11 +35,13 @@
"reprocess_merged_lambdas_kstyle",
mainClassName,
testBuilder ->
- testBuilder.addOptionsModification(
- options -> {
- options.enableInlining = true;
- options.enableClassInlining = true;
- options.enableLambdaMerging = true;
- }));
+ testBuilder
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addOptionsModification(
+ options -> {
+ options.enableInlining = true;
+ options.enableClassInlining = true;
+ options.enableLambdaMerging = true;
+ }));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
index 1dcdcfb..5032ea2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
@@ -35,7 +35,8 @@
"lambdas_jstyle_runnable",
mainClassName,
testBuilder ->
- testBuilder.addOptionsModification(
- options -> options.inliningInstructionAllowance = 3));
+ testBuilder
+ .addDontWarnJetBrainsAnnotations()
+ .addOptionsModification(options -> options.inliningInstructionAllowance = 3));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
index 0dd8a62..e9f4e46 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
@@ -139,6 +139,7 @@
.setProgramConsumer(new ArchiveConsumer(featureCode, false))
.build())
.allowDiagnosticWarningMessages()
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.assertAllWarningMessagesMatch(
equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
index 57cdae7..c33d03b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
@@ -94,6 +94,7 @@
inspector.assertNoClassesMerged();
}
})
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile();
Path path = compileResult.writeToZip();
compileResult
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
index c261c25..663c081 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
@@ -71,6 +71,7 @@
options -> options.horizontalClassMergerOptions().disableKotlinLambdaMerging())
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(PKG_NAME + ".SimpleKt")
+ .addDontWarnJetBrainsNotNullAnnotation()
.applyIf(
splitGroup,
b ->
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
index 31b489a..b4fd614 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
@@ -86,6 +86,7 @@
.addKeepAllClassesRuleWithAllowObfuscation()
.addKeepRules("-keep class " + PKG_LIB + ".LibKt { *; }")
.addKeepRules("-keep class kotlin.Metadata { *; }")
+ .addDontWarnJetBrainsAnnotations()
.applyIf(keepUnit, b -> b.addKeepRules("-keep class kotlin.Unit { *; }"))
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.allowDiagnosticWarningMessages()
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 ea9ed33..b6d7701 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
@@ -104,7 +104,6 @@
.addKeepRules("-keepclassmembers,allowaccessmodification class **.Lib$Comp { *; }")
.addKeepRules("-keep,allowaccessmodification,allowobfuscation class **.Lib$Comp { *; }")
.addKeepRules("-keep,allowaccessmodification,allowobfuscation class **.LibKt { *; }")
- .addKeepRules("-allowaccessmodification")
.addApplyMapping(
StringUtils.lines(
PKG_LIB + ".Lib -> " + PKG_LIB + ".LibReference:",
@@ -115,6 +114,9 @@
" void staticPrivate() -> staticPrivateReference",
" void staticInternal() -> staticInternalReference"))
.addKeepRuntimeVisibleAnnotations()
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
+ .allowAccessModification()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
index 428103f..a285149 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
@@ -121,6 +121,8 @@
ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS,
ProguardKeepAttributes.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS,
ProguardKeepAttributes.RUNTIME_VISIBLE_TYPE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
index 0ff40ff..8db1944 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
@@ -76,6 +76,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
index 2c2ae83..4e7d224 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
@@ -101,6 +101,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -157,6 +158,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.writeToZip();
Path main =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
index 56fd483..065d63f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
@@ -68,6 +68,8 @@
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAllAttributes()
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.compile()
.writeToZip();
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
index b8c5ac2..15f68ea 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
@@ -68,6 +68,8 @@
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAllAttributes()
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.compile()
.writeToZip();
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
index d71248e..b43f846 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
@@ -71,6 +71,8 @@
.addProgramFiles(jars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
+ .addDontWarnKotlin()
.compile()
.inspect(
inspector ->
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
index 15112f6..2ccbb3a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
@@ -51,6 +51,7 @@
.addKeepKotlinMetadata()
.addKeepRules(StringUtils.joinLines("-if class *.Metadata", "-keep class <1>.io.** { *; }"))
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspect);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
index fb4dab9..feca0f8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
@@ -53,6 +53,7 @@
.addKeepAllClassesRule()
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspectEmptyValuesAreNotPresent);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
index ecaea79..fbfc10f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
@@ -88,6 +88,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
index 09d3af7..c7b9ea6 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
@@ -94,6 +94,7 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.ImplKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
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 d025713..bdcb905 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
@@ -93,6 +93,7 @@
// To keep ...$Companion structure
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(codeInspector -> inspect(codeInspector, true))
.writeToZip();
@@ -135,6 +136,7 @@
// To keep ...$Companion structure
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(codeInspector -> inspect(codeInspector, false))
.writeToZip();
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 ac363d4..f9124bd 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
@@ -92,6 +92,7 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -146,6 +147,7 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
index 327ec34..c78cea1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
@@ -88,6 +88,7 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -151,6 +152,7 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
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 91ed797..5c8468d 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
@@ -86,6 +86,7 @@
// Keep the BKt method, which will be called from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -147,6 +148,7 @@
// Keep the BKt method, which will be called from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
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 c9210a1..db348d0 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
@@ -87,6 +87,7 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
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 a65c4b9..65207dd 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
@@ -89,6 +89,7 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
index e635091..f3c59d9 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
@@ -87,7 +87,6 @@
Path out =
testForR8(parameters.getBackend())
// Intentionally not providing baseLibJar as lib file nor classpath file.
- .addClasspathFiles()
.addProgramFiles(
extLibJarMap.getForConfiguration(kotlinc, targetVersion),
appJarMap.getForConfiguration(kotlinc, targetVersion))
@@ -97,6 +96,9 @@
// Keep the main entry.
.addKeepMainRule(main)
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarn(PKG + ".**")
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.allowDiagnosticWarningMessages()
// -dontoptimize so that basic code structure is kept.
.noOptimization()
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 8adeb48..3949d6e 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
@@ -91,6 +91,7 @@
.addKeepRules("-keep class **.UtilKt")
.addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -135,6 +136,7 @@
// Keep yet rename joinOf*(String).
.addKeepRules("-keepclassmembers,allowobfuscation class * { ** joinOf*(...); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
index a2a85c3..f84fa48 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
@@ -78,6 +78,7 @@
// Keep Itf, but allow minification.
.addKeepRules("-keep,allowobfuscation class **.Itf")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
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 d012f10..af4c9b6 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
@@ -84,6 +84,7 @@
.addKeepRules("-keep class **.Person { <init>(...); }")
.addKeepRules("-keepclassmembers class **.Person { *** get*(); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectGetterOnly)
.writeToZip();
@@ -179,6 +180,7 @@
// Keep LibKt extension methods
.addKeepRules("-keep class **.LibKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectSetterOnly)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
index 9641f64..0113f19 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
@@ -76,6 +76,7 @@
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
index 9783f3b..c8144f4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
@@ -78,6 +78,7 @@
// Keep Itf, but allow minification.
.addKeepRules("-keep,allowobfuscation class **.Itf")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
index f33fc30..db927a8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
@@ -77,6 +77,7 @@
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.addKeepAttributes(
ProguardKeepAttributes.INNER_CLASSES, ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.writeToZip();
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
index 2dbbc48..ef43f6e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
@@ -87,6 +87,7 @@
// Keep the factory object and utils
.addKeepRules("-keep class **.ExprFactory { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspectValid)
.writeToZip();
@@ -152,6 +153,7 @@
// Keep the extension function
.addKeepRules("-keep class **.LibKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectInvalid)
.writeToZip();
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 edade6e..e680d6e 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
@@ -129,6 +129,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
index 788abf2..acdda5b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
@@ -133,6 +133,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
index 133dd37..ac232d7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
@@ -81,6 +81,7 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
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 83b8e62..0558ebc 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
@@ -89,6 +89,8 @@
.addProgramFiles(kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.compile()
.inspect(this::inspect)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
index 40c7573..056b18b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
@@ -60,6 +60,7 @@
.applyIf(keepMetadata, TestShrinkerBuilder::addKeepKotlinMetadata)
.addKeepRuntimeVisibleAnnotations()
.allowDiagnosticWarningMessages()
+ .addDontWarnJetBrainsAnnotations()
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(inspector -> inspect(inspector, keepMetadata));
@@ -72,6 +73,7 @@
.addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
@@ -84,6 +86,7 @@
.addLibraryFiles(ToolHelper.getJava8RuntimeJar())
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
+ .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
@@ -94,6 +97,8 @@
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
+ .addDontWarnJetBrainsNotNullAnnotation()
+ .addDontWarnKotlin()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
index 8c681bd..74159a6 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
@@ -47,6 +47,7 @@
.addKeepKotlinMetadata()
.addKeepRules("-keep class kotlin.io.** { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspect);
}
@@ -59,6 +60,7 @@
.addKeepRules("-keep class kotlin.io.** { *; }")
.addKeepRules("-if class *", "-keep class kotlin.Metadata { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspect);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
index 3e62729..0b65ec3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
@@ -44,6 +44,7 @@
.addKeepAllClassesRule()
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(
inspector ->
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
index 39793cf..3d3386c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
@@ -75,6 +75,7 @@
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepRules("-keep class " + PKG_LIB + ".Sub { <init>(); *** kept(); }")
.addKeepRuntimeVisibleAnnotations()
+ .addDontWarnKotlinMetadata()
.noMinification()
.compile()
.inspect(this::checkPruned)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 168cbc5..1a2cd73 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -61,6 +61,7 @@
.addKeepMainRule(mainClassName)
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
index 9cd2614..e23ac8f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
@@ -56,6 +56,7 @@
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.0"));
}
@@ -68,6 +69,7 @@
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.0"));
}
@@ -80,6 +82,7 @@
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.2"));
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java b/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
index d7eeae4..fe05714 100644
--- a/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
@@ -46,6 +46,7 @@
options.enableEnumValueOptimization = enableSwitchMapRemoval;
options.enableEnumSwitchMapRemoval = enableSwitchMapRemoval;
})
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getRuntime())
.noMinification()
.compile()
diff --git a/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java b/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
index 53b9d9b..ac7eb23 100644
--- a/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
@@ -96,6 +96,7 @@
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.allowDiagnosticWarningMessages()
+ .addDontWarnJetBrains()
.compile()
.writeToZip(foo.toPath())
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
diff --git a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
index 6b70ca2..92b6b97 100644
--- a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
@@ -76,6 +76,7 @@
.allowAccessModification()
.allowDiagnosticWarningMessages(parameters.isCfRuntime())
.addKeepMainRule(MAIN)
+ .addDontWarnJetBrainsNotNullAnnotation()
.compileWithExpectedDiagnostics(
diagnostics ->
diagnostics.assertAllWarningsMatch(
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
new file mode 100644
index 0000000..6cb7ab4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexDevirtualizerTest.java
@@ -0,0 +1,178 @@
+// 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.maindexlist;
+
+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.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CheckCastInstructionSubject;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexDevirtualizerTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MainDexDevirtualizerTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ assumeTrue(parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isDalvik());
+ runTest(
+ testBuilder -> {},
+ (inspector, mainDexClasses) -> {
+ assertTrue(mainDexClasses.isEmpty());
+ // Verify that the call to I.foo in Main.class has been changed to A.foo by checking for a
+ // cast.
+ ClassSubject clazz = inspector.clazz(Main.class);
+ assertThat(clazz, isPresentAndNotRenamed());
+ MethodSubject main = clazz.uniqueMethodWithName("main");
+ assertThat(main, isPresent());
+ List<CheckCastInstructionSubject> checkCasts =
+ main.streamInstructions()
+ .filter(InstructionSubject::isCheckCast)
+ .map(InstructionSubject::asCheckCast)
+ .collect(Collectors.toList());
+ assertEquals(1, checkCasts.size());
+ ClassSubject a = inspector.clazz(A.class);
+ assertThat(a, isPresentAndRenamed());
+ assertEquals(
+ a.getFinalDescriptor(), checkCasts.get(0).getType().getDescriptor().toString());
+ });
+ }
+
+ @Test
+ public void testMainDexClasses() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ assumeTrue(parameters.getDexRuntimeVersion().isDalvik());
+ runTest(
+ r8FullTestBuilder ->
+ r8FullTestBuilder.addMainDexListClasses(I.class, Provider.class, Main.class),
+ this::inspect);
+ }
+
+ @Test
+ public void testMainDexTracing() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ assumeTrue(parameters.getDexRuntimeVersion().isDalvik());
+ runTest(
+ r8FullTestBuilder -> r8FullTestBuilder.addMainDexClassRules(Main.class, I.class),
+ this::inspect);
+ }
+
+ private void runTest(
+ ThrowableConsumer<R8FullTestBuilder> setMainDexConsumer,
+ BiConsumer<CodeInspector, List<String>> resultConsumer)
+ throws Exception {
+ Box<String> mainDexStringList = new Box<>("");
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class, Provider.class, A.class, Main.class)
+ .enableNoVerticalClassMergingAnnotations()
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .addKeepMainRule(Main.class)
+ .addKeepClassRulesWithAllowObfuscation(I.class)
+ .setMinApi(parameters.getApiLevel())
+ .applyIf(
+ parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isDalvik(),
+ builder ->
+ builder.setMainDexListConsumer(ToolHelper.consumeString(mainDexStringList::set)))
+ .apply(setMainDexConsumer)
+ .run(parameters.getRuntime(), Main.class)
+ .apply(
+ result ->
+ resultConsumer.accept(
+ result.inspector(),
+ mainDexStringList.get().equals("")
+ ? new ArrayList<>()
+ : StringUtils.splitLines(mainDexStringList.get())));
+ }
+
+ private void inspect(CodeInspector inspector, List<String> mainDexClasses) {
+ assertEquals(4, inspector.allClasses().size());
+ assertEquals(3, mainDexClasses.size());
+ inspectClassInMainDex(Main.class, inspector, mainDexClasses);
+ inspectClassInMainDex(I.class, inspector, mainDexClasses);
+ inspectClassInMainDex(Provider.class, inspector, mainDexClasses);
+ ClassSubject aClass = inspector.clazz(A.class);
+ assertThat(aClass, isPresentAndRenamed());
+ assertThat(mainDexClasses, not(hasItem(aClass.getFinalBinaryName() + ".class")));
+ }
+
+ private void inspectClassInMainDex(
+ Class<?> clazz, CodeInspector inspector, List<String> mainDexClasses) {
+ ClassSubject classSubject = inspector.clazz(clazz);
+ assertThat(classSubject, isPresent());
+ assertThat(mainDexClasses, hasItem(classSubject.getFinalBinaryName() + ".class"));
+ }
+
+ @NoVerticalClassMerging
+ public interface I {
+
+ @NeverInline
+ void foo();
+ }
+
+ public static class Provider {
+ @NeverInline
+ public static I getImpl() {
+ return new A(); // <-- We will call-site optimize getImpl() to always return A.
+ }
+ }
+
+ @NeverClassInline
+ public static class A implements I {
+
+ @Override
+ @NeverInline
+ public void foo() {
+ System.out.println("A::foo");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ // The de-virtualizer will try and rebind from I.foo to A.foo.
+ Provider.getImpl().foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
new file mode 100644
index 0000000..94392e6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
@@ -0,0 +1,151 @@
+// 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.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.NoStaticClassMerging;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+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.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexListFromGenerateMainDexInliningTest extends TestBase {
+
+ private static List<ClassReference> mainDexList;
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+ .build();
+ }
+
+ @BeforeClass
+ public static void setup() throws Exception {
+ mainDexList =
+ testForMainDexListGenerator(getStaticTemp())
+ .addInnerClasses(MainDexListFromGenerateMainDexInliningTest.class)
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .addMainDexRules(
+ "-keep class " + Main.class.getTypeName() + " {",
+ " public static void main(java.lang.String[]);",
+ "}")
+ .run()
+ .getMainDexList();
+ }
+
+ public MainDexListFromGenerateMainDexInliningTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ // The generated main dex list should contain Main (which is a root) and A (which is a direct
+ // dependency of Main).
+ assertEquals(2, mainDexList.size());
+ assertEquals(A.class.getTypeName(), mainDexList.get(0).getTypeName());
+ assertEquals(Main.class.getTypeName(), mainDexList.get(1).getTypeName());
+
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addInliningAnnotations()
+ .addKeepClassAndMembersRules(Main.class)
+ .addMainDexListClassReferences(mainDexList)
+ .collectMainDexClasses()
+ .enableInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableNoStaticClassMergingAnnotations()
+ .noMinification()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ CodeInspector inspector = compileResult.inspector();
+ ClassSubject mainClassSubject = inspector.clazz(Main.class);
+ assertThat(mainClassSubject, isPresent());
+
+ MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+ assertThat(fooMethodSubject, isPresent());
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ // TODO(b/178353726): Should be present, but was inlined.
+ assertThat(aClassSubject, isAbsent());
+
+ MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+ // TODO(b/178353726): Should be present, but was inlined.
+ assertThat(barMethodSubject, isAbsent());
+
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ assertThat(bClassSubject, isPresent());
+
+ MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+ assertThat(bazMethodSubject, isPresent());
+
+ // TODO(b/178353726): foo() should invoke bar() and bar() should invoke baz().
+ assertThat(fooMethodSubject, invokesMethod(bazMethodSubject));
+
+ // TODO(b/178353726): Main is the only class guaranteed to be in the main dex, but it has a
+ // direct reference to B.
+ compileResult.inspectMainDexClasses(
+ mainDexClasses -> {
+ assertEquals(1, mainDexClasses.size());
+ assertEquals(mainClassSubject.getFinalName(), mainDexClasses.iterator().next());
+ });
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ System.out.println("Main.main()");
+ }
+
+ static void foo() {
+ // TODO(b/178353726): Should not allow inlining bar into foo(), since that adds B as a direct
+ // dependence, and we don't include the direct dependencies of main dex list classes.
+ A.bar();
+ }
+ }
+
+ @NoHorizontalClassMerging
+ @NoStaticClassMerging
+ static class A {
+
+ static void bar() {
+ B.baz();
+ }
+ }
+
+ @NoHorizontalClassMerging
+ @NoStaticClassMerging
+ static class B {
+
+ @NeverInline
+ static void baz() {
+ System.out.println("B.baz");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java
new file mode 100644
index 0000000..82f5e7d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java
@@ -0,0 +1,92 @@
+// 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.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MainDexListInliningTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+ .build();
+ }
+
+ public MainDexListInliningTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addMainDexListClasses(Main.class)
+ .collectMainDexClasses()
+ .enableNoHorizontalClassMergingAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ CodeInspector inspector = compileResult.inspector();
+
+ ClassSubject mainClassSubject = inspector.clazz(Main.class);
+ assertThat(mainClassSubject, isPresent());
+
+ // A is absent due to inlining.
+ // TODO(b/178353726): Inlining should be prohibited.
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isAbsent());
+
+ // B should be referenced from Main.main.
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ assertThat(bClassSubject, isPresent());
+
+ compileResult.inspectMainDexClasses(
+ mainDexClasses -> {
+ assertTrue(mainDexClasses.contains(mainClassSubject.getFinalName()));
+ assertFalse(mainDexClasses.contains(bClassSubject.getFinalName()));
+ });
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ // Should be inlined.
+ A.m();
+ }
+ }
+
+ @NoHorizontalClassMerging
+ static class A {
+
+ public static void m() {
+ System.out.println(B.class);
+ }
+ }
+
+ @NoHorizontalClassMerging
+ static class B {}
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java
new file mode 100644
index 0000000..7041c75
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java
@@ -0,0 +1,113 @@
+// 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.maindexlist;
+
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilation;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexListMergeInRootTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ }
+
+ public MainDexListMergeInRootTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testMainDexTracing() {
+ assumeTrue(parameters.getDexRuntimeVersion().isDalvik());
+ assertFailsCompilation(
+ () ->
+ testForR8(parameters.getBackend())
+ .addProgramClasses(OutsideMainDex.class, InsideA.class, InsideB.class, Main.class)
+ .addKeepClassAndMembersRules(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableNeverClassInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableInliningAnnotations()
+ .noMinification()
+ .addMainDexRules(
+ "-keep class "
+ + Main.class.getTypeName()
+ + " { public static void main(***); }")
+ .addOptionsModification(
+ options -> {
+ options.testing.checkForNotExpandingMainDexTracingResult = true;
+ })
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString(
+ "Class com.android.tools.r8.maindexlist"
+ + ".MainDexListMergeInRootTest$OutsideMainDex"
+ + " was not a main dex root in the first round")));
+ }));
+ }
+
+ @NoHorizontalClassMerging
+ @NeverClassInline
+ public static class OutsideMainDex {
+
+ @NeverInline
+ public void print(int i) {
+ System.out.println("OutsideMainDex::print" + i);
+ }
+ }
+
+ @NeverClassInline
+ public static class InsideA {
+
+ public void bar() {
+ System.out.println("A::live");
+ }
+
+ /* Not a traced root */
+ @NeverInline
+ public void foo(int i) {
+ new OutsideMainDex().print(i);
+ }
+ }
+
+ @NeverClassInline
+ public static class InsideB {
+
+ @NeverInline
+ public void foo(int i) {
+ System.out.println("InsideB::live" + i);
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ new InsideB().foo(args.length);
+ new InsideA().bar();
+ }
+
+ public void keptToKeepInsideANotLive() {
+ new InsideA().foo(System.currentTimeMillis() > 0 ? 0 : 1);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListNoDirectDependenciesTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListNoDirectDependenciesTest.java
new file mode 100644
index 0000000..8f5d997
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListNoDirectDependenciesTest.java
@@ -0,0 +1,86 @@
+// 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.maindexlist;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MainDexListNoDirectDependenciesTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+ .build();
+ }
+
+ public MainDexListNoDirectDependenciesTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addMainDexListClasses(A.class)
+ .addMainDexClassRules(B.class)
+ .collectMainDexClasses()
+ .noTreeShaking()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ CodeInspector inspector = compileResult.inspector();
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ ClassSubject referencedFromAClassSubject = inspector.clazz(ReferencedFromA.class);
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ ClassSubject referencedFromBClassSubject = inspector.clazz(ReferencedFromB.class);
+
+ compileResult.inspectMainDexClasses(
+ mainDexClasses -> {
+ assertTrue(mainDexClasses.contains(aClassSubject.getFinalName()));
+ // It is assumed that the provided main dex list includes its direct dependencies.
+ // Therefore, we explicitly do not include the direct dependencies of the main dex list
+ // classes in the final main dex, since this would lead to the dependencies of the
+ // dependencies being included in the main dex.
+ assertFalse(mainDexClasses.contains(referencedFromAClassSubject.getFinalName()));
+ assertTrue(mainDexClasses.contains(bClassSubject.getFinalName()));
+ assertTrue(mainDexClasses.contains(referencedFromBClassSubject.getFinalName()));
+ });
+ }
+
+ static class A {
+
+ public void m() {
+ System.out.println(ReferencedFromA.class);
+ }
+ }
+
+ static class ReferencedFromA {}
+
+ static class B {
+
+ public void m() {
+ System.out.println(ReferencedFromB.class);
+ }
+ }
+
+ static class ReferencedFromB {}
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
index 7565cf7..1bbcb9e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -6,6 +6,7 @@
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@ -16,6 +17,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.FileUtils;
import com.google.common.collect.ImmutableList;
@@ -59,8 +61,8 @@
@Override
public void finished(DiagnosticsHandler handler) {
String string = builder.toString();
- assertTrue(string.contains(testClassMainDexName));
- assertTrue(string.contains("Lambda"));
+ assertThat(string, containsString(testClassMainDexName));
+ assertThat(string, SyntheticItemsTestUtils.containsExternalSyntheticReference());
}
}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index 52b60fe..ccaa66a 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -22,11 +22,12 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestCompilerBuilder;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ir.desugar.LambdaRewriter;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -210,7 +211,12 @@
Paths.get(EXAMPLE_SRC_DIR, "multidex", "main-dex-rules.txt"),
Paths.get(EXAMPLE_O_SRC_DIR, "multidex004", "ref-list-1.txt"),
Paths.get(EXAMPLE_O_SRC_DIR, "multidex004", "ref-list-1.txt"),
- AndroidApiLevel.I);
+ AndroidApiLevel.I,
+ builder ->
+ builder
+ .applyIf(
+ backend.isDex(), TestShrinkerBuilder::addDontWarnCompilerSynthesizedAnnotations)
+ .addOptionsModification(options -> options.enableInlining = false));
}
@Test
@@ -433,13 +439,13 @@
for (int i = 0; i < refList.length; i++) {
String reference = refList[i].trim();
// The main dex list generator does not do any lambda desugaring.
- if (!isLambda(reference)) {
+ if (!isExternalSyntheticLambda(reference)) {
if (mainDexGeneratorMainDexList.size() <= i - nonLambdaOffset) {
fail("Main dex list generator is missing '" + reference + "'");
}
String fromList = mainDexGeneratorMainDexList.get(i - nonLambdaOffset);
String fromConsumer = mainDexGeneratorMainDexListFromConsumer.get(i - nonLambdaOffset);
- if (isLambda(fromList)) {
+ if (isExternalSyntheticLambda(fromList)) {
assertEquals(Backend.DEX, backend);
assertEquals(fromList, fromConsumer);
nonLambdaOffset--;
@@ -481,8 +487,8 @@
assertArrayEquals(entriesUnsorted, entriesSorted);
}
- private boolean isLambda(String mainDexEntry) {
- return mainDexEntry.contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX);
+ private boolean isExternalSyntheticLambda(String mainDexEntry) {
+ return SyntheticItemsTestUtils.isExternalLambda(Reference.classFromDescriptor(mainDexEntry));
}
private String mainDexStringToDescriptor(String mainDexString) {
@@ -492,11 +498,8 @@
}
private void checkSameMainDexEntry(String reference, String computed) {
- if (isLambda(reference)) {
- // For lambda classes we check that there is a lambda class for the right containing
- // class. However, we do not check the hash for the generated lambda class. The hash
- // changes for different compiler versions because different compiler versions generate
- // different lambda implementation method names.
+ if (isExternalSyntheticLambda(reference)) {
+ // For synthetic classes we check that the context classes match.
reference = reference.substring(0, reference.lastIndexOf('$'));
computed = computed.substring(0, computed.lastIndexOf('$'));
}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
index d102004..9fa7fe9 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ir.desugar.LambdaRewriter;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -100,10 +100,11 @@
inspector.allClasses().stream()
.anyMatch(
clazz ->
- clazz.getOriginalName().contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX)
+ clazz.isSynthesizedJavaLambdaClass()
&& clazz
- .getOriginalName()
- .contains("$" + lambdaHolder.getSimpleName() + "$")));
+ .getOriginalReference()
+ .equals(
+ SyntheticItemsTestUtils.syntheticLambdaClass(lambdaHolder, 0))));
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java b/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
index 4f5e54a..22bad85 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
@@ -57,6 +57,7 @@
.addKeepMainRule(mainClass)
// Include main dex rule for class Static.
.addMainDexClassRules(Main.class, Static.class)
+ .enableForceInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::classStaticGone)
@@ -69,9 +70,11 @@
.setMinApi(AndroidApiLevel.K)
.addProgramClasses(testClassesWithoutStatic)
.addKeepMainRule(mainClass)
+ .addDontWarn(Static.class)
// Include explicit main dex entry for class Static.
.addMainDexListClasses(Static.class)
.allowDiagnosticWarningMessages()
+ .enableForceInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::classStaticGone)
@@ -91,7 +94,9 @@
.addMainDexListClasses(Main.class, Static.class)
// Include main dex rule for class Static2.
.addMainDexClassRules(Static2.class)
+ .addDontWarn(Static.class)
.allowDiagnosticWarningMessages()
+ .enableForceInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::classStaticGone)
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index 837459c..8dd68fc 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -64,6 +64,7 @@
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepClassRulesWithAllowObfuscation(ENUM_CLASS_NAME)
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
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 0ab866f..165d0f7 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldNamingObfuscationDictionaryTest.java
@@ -99,6 +99,7 @@
.addInnerClasses(FieldNamingObfuscationDictionaryTest.class)
.addKeepRules("-overloadaggressively", "-obfuscationdictionary " + dictionary.toString())
.addKeepMainRule(Runner.class)
+ .enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/naming/InterfaceConstructorRenamingTest.java b/src/test/java/com/android/tools/r8/naming/InterfaceConstructorRenamingTest.java
index ebd7420..7ec2589 100644
--- a/src/test/java/com/android/tools/r8/naming/InterfaceConstructorRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/InterfaceConstructorRenamingTest.java
@@ -6,7 +6,6 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.ArchiveClassFileProvider;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -16,10 +15,8 @@
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.Collections;
-import java.util.concurrent.ExecutionException;
import java.util.function.Function;
import org.junit.ClassRule;
import org.junit.Test;
@@ -44,17 +41,11 @@
@ClassRule public static TemporaryFolder staticTemp = ToolHelper.getTemporaryFolderForTest();
private static R8TestCompileResult compile(Backend backend)
- throws com.android.tools.r8.CompilationFailedException, IOException, ExecutionException {
+ throws com.android.tools.r8.CompilationFailedException, IOException {
R8TestCompileResult compileResult =
testForR8(staticTemp, backend)
.addProgramClasses(TestInterface.class, TestClass.class)
.addKeepMainRule(TestClass.class)
- .addLibraryProvider(
- new ArchiveClassFileProvider(
- ToolHelper.getJava8RuntimeJar(),
- name ->
- ImmutableSet.of("java/lang/Object", "java/lang/System")
- .contains(name.replace(".class", ""))))
.setMinApi(AndroidApiLevel.B)
.compile()
.assertNoMessages();
diff --git a/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java b/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
index efb5d35..5b8dc11 100644
--- a/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
@@ -51,7 +51,6 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @FunctionalInterface
@NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index 70a9cb2..3d143a1 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -88,6 +88,7 @@
.addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(mainClassName)
+ .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.minification(minification)
.compile()
@@ -149,6 +150,7 @@
"-" + NoHorizontalClassMergingRule.RULE_NAME + " class **." + targetClassName,
"-" + NoStaticClassMergingRule.RULE_NAME + " class **." + targetClassName,
"-neverinline class **." + targetClassName + " { <methods>; }"))
+ .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.minification(minification)
.compile()
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
index 4d000bb..3cb240b 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
@@ -123,7 +123,8 @@
List<FoundMethodSubject> methods =
inspector.clazz(LibrarySubclass.class).allMethods();
assertEquals(3, methods.size());
- assertEquals(1, methods.stream().filter(m -> m.isInstanceInitializer()).count());
+ assertEquals(
+ 1, methods.stream().filter(FoundMethodSubject::isInstanceInitializer).count());
assertEquals(
1, methods.stream().filter(m -> m.getFinalName().contains("main")).count());
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java
index 0d0af87..9db718e 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java
@@ -104,7 +104,6 @@
}
}
- @FunctionalInterface
public interface I {
void doStuff();
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
index 6d61f51..2f7c01c 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
@@ -26,7 +26,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public ApplyMappingInnerClassesPreserveTest(TestParameters parameters) {
@@ -41,7 +41,7 @@
.addProgramClassesAndInnerClasses(InnerLibraryClass.class)
.addKeepAllClassesRuleWithAllowObfuscation()
.addKeepClassAndMembersRulesWithAllowObfuscation(InnerLibraryClass.class)
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile();
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(ProgramClassWithSimpleLibraryReference.class)
@@ -49,7 +49,7 @@
.addKeepMainRule(ProgramClassWithSimpleLibraryReference.class)
.addApplyMapping(libraryCompileResult.getProguardMap())
.addKeepAttributes("EnclosingMethod", "InnerClasses")
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.noTreeShaking()
.compile()
.addRunClasspathFiles(libraryCompileResult.writeToZip())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java
index 6887f59..de95714 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java
@@ -86,7 +86,6 @@
void foo();
}
- @NeverClassInline
public static class Main implements TestInterface {
public static void main(String[] args) {
@@ -94,7 +93,6 @@
}
@Override
- @NeverInline
public void foo() {
System.out.println("Hello World!");
}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMultipleInterfacesTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMultipleInterfacesTest.java
index b56464e..af6c004 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMultipleInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMultipleInterfacesTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.naming.applymapping;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverInline;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -46,7 +45,6 @@
public static class ImplementsI2I3 implements I2, I3 {
@Override
- @NeverInline
public String foo(String bar) {
System.out.print("Hello" + bar);
return bar;
@@ -55,7 +53,6 @@
public static class ImplementsI3 implements I3 {
@Override
- @NeverInline
public String foo(String bar) {
System.out.print("Goodbye");
return bar;
@@ -84,7 +81,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public ApplyMappingMultipleInterfacesTest(TestParameters parameters) {
@@ -98,19 +95,24 @@
testForR8(parameters.getBackend())
.addProgramClasses(I2Minified.class, I3Minified.class)
.addKeepAllClassesRule()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile();
testForR8(parameters.getBackend())
.addClasspathClasses(I2.class, I3.class)
.addProgramClasses(MainForImplements.class, ImplementsI2I3.class, ImplementsI3.class)
.addKeepMainRule(MainForImplements.class)
.addApplyMapping(
- I2.class.getTypeName() + " -> " + I2Minified.class.getTypeName() + ":\n" +
- " java.lang.String foo(java.lang.String) -> a\n" +
- I3.class.getTypeName() + " -> " + I3Minified.class.getTypeName() + ":\n" +
- " java.lang.String foo(java.lang.String) -> a"
- )
- .setMinApi(parameters.getRuntime())
+ I2.class.getTypeName()
+ + " -> "
+ + I2Minified.class.getTypeName()
+ + ":\n"
+ + " java.lang.String foo(java.lang.String) -> a\n"
+ + I3.class.getTypeName()
+ + " -> "
+ + I3Minified.class.getTypeName()
+ + ":\n"
+ + " java.lang.String foo(java.lang.String) -> a")
+ .setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(libraryResult.writeToZip())
.run(parameters.getRuntime(), MainForImplements.class)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/shared/InnerLibraryClass.java b/src/test/java/com/android/tools/r8/naming/applymapping/shared/InnerLibraryClass.java
index 1e751d1..8cfa59b 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/shared/InnerLibraryClass.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/shared/InnerLibraryClass.java
@@ -4,12 +4,9 @@
package com.android.tools.r8.naming.applymapping.shared;
-import com.android.tools.r8.NeverInline;
-
public class InnerLibraryClass {
public static class LibraryClass {
- @NeverInline
public void foo() {
System.out.println("LibraryClass.foo()");
}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/shared/ProgramClassWithSimpleLibraryReference.java b/src/test/java/com/android/tools/r8/naming/applymapping/shared/ProgramClassWithSimpleLibraryReference.java
index 42b7907..a42654f 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/shared/ProgramClassWithSimpleLibraryReference.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/shared/ProgramClassWithSimpleLibraryReference.java
@@ -12,7 +12,6 @@
public static class SubLibraryClass extends LibraryClass {
@Override
- @NeverInline
public void foo() {
System.out.println("SubLibraryClass.foo()");
super.foo();
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 de81c15..b2614a3 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
@@ -44,7 +44,7 @@
Class<?> mainClass = genericTypeLive ? MainGenericTypeLive.class : MainGenericTypeNotLive.class;
testForR8(backend)
.minification(minify)
- .addProgramClasses(GetClassUtil.class, A.class, GenericType.class, mainClass)
+ .addProgramClasses(GetClassUtil.class, A.class, GenericType.class, mainClass, Marker.class)
.addKeepMainRule(mainClass)
.addKeepRules(
"-keep class " + GetClassUtil.class.getTypeName() + " {",
diff --git a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
index ef791d3..69f0148 100644
--- a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
@@ -64,6 +64,7 @@
options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
options.enableClassInlining = false;
})
+ .addDontWarnJetBrainsAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutput(StringUtils.lines("11", "12"))
diff --git a/src/test/java/com/android/tools/r8/naming/methodparameters/MethodParametersTest.java b/src/test/java/com/android/tools/r8/naming/methodparameters/MethodParametersTest.java
index 30e72d7..a8e337e 100644
--- a/src/test/java/com/android/tools/r8/naming/methodparameters/MethodParametersTest.java
+++ b/src/test/java/com/android/tools/r8/naming/methodparameters/MethodParametersTest.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
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.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
@@ -58,7 +59,10 @@
.addKeepClassAndMembersRulesWithAllowObfuscation(MethodParametersTest.class)
.addKeepMainRule(MethodParametersTest.class)
.addKeepRules(keepMethodParameters ? "-keepattributes MethodParameters" : "")
- .setMinApi(AndroidApiLevel.L)
+ .setMinApi(keepMethodParameters ? AndroidApiLevel.O : AndroidApiLevel.L)
+ // java.lang.reflect.Parameter was introduced in API level 26 (O).
+ .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.O))
+ .compile()
.run(parameters.getRuntime(), MethodParametersTest.class);
if (keepMethodParameters) {
checkOutputContainsAll(runResult.getStdOut());
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
index 3959d84..2836f61 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
@@ -14,6 +14,8 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.naming.retrace.StackTrace.StackTraceLine;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
@@ -57,7 +59,8 @@
}
private boolean isSynthesizedLambdaFrame(StackTraceLine line) {
- return line.className.contains("-$$Lambda$");
+ // TODO(141287349): The mapping should not map the external name to the internal name!
+ return SyntheticItemsTestUtils.isInternalLambda(Reference.classFromTypeName(line.className));
}
private void checkLambdaFrame(StackTrace retracedStackTrace) {
@@ -141,7 +144,6 @@
}
// Custom consumer functional interface, as java.util.function.Consumer is not present on Android.
-@FunctionalInterface
interface ConsumerDesugarLambdaRetraceTest<T> {
void accept(T value);
}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
index 2ffe206..344a716 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
@@ -84,7 +84,9 @@
@Override
public void configure(R8TestBuilder<?> builder) {
- builder.applyIf(mode == CompilationMode.RELEASE, R8TestBuilder::enableForceInliningAnnotations);
+ builder
+ .addForceInliningAnnotations()
+ .applyIf(mode == CompilationMode.RELEASE, R8TestBuilder::enableForceInliningAnnotations);
}
@Override
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarLambdaRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarLambdaRetraceTest.java
index a527d93..458cb07 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarLambdaRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarLambdaRetraceTest.java
@@ -166,7 +166,6 @@
}
// Custom consumer functional interface, as java.util.function.Consumer is not present on Android.
-@FunctionalInterface
interface ConsumerDesugarLambdaRetraceTest<T> {
void accept(T value);
}
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarStaticInterfaceMethodsRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarStaticInterfaceMethodsRetraceTest.java
index 2034f5d..47240a5 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarStaticInterfaceMethodsRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/DesugarStaticInterfaceMethodsRetraceTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
@@ -33,6 +34,11 @@
}
@Override
+ public void configure(R8TestBuilder builder) {
+ builder.enableInliningAnnotations();
+ }
+
+ @Override
public Collection<Class<?>> getClasses() {
return ImmutableList.of(
getMainClass(), InterfaceWithStaticMethod1.class, InterfaceWithStaticMethod2.class);
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/RetraceTestBase.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/RetraceTestBase.java
index e94483f..62c4de9 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/RetraceTestBase.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/RetraceTestBase.java
@@ -48,12 +48,12 @@
public void runTest(List<String> keepRules, BiConsumer<StackTrace, StackTrace> checker)
throws Exception {
-
R8TestRunResult result =
(compat ? testForR8Compat(backend) : testForR8(backend))
.setMode(mode)
.enableProguardTestOptions()
.addProgramClasses(getClasses())
+ .addForceInliningAnnotations()
.addKeepMainRule(getMainClass())
.addKeepRules(keepRules)
.apply(this::configure)
diff --git a/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java b/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
index 1151d20..ced781f 100644
--- a/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
+++ b/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Test;
@@ -21,7 +22,10 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+ .build();
}
public Regress63935662(TestParameters parameters) {
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 e548bcf..c8a47ca 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
@@ -49,6 +49,7 @@
.addInnerClasses(getClass())
.addClassObfuscationDictionary("a")
.addKeepMainRule(TestClass.class)
+ .addMemberValuePropagationAnnotations()
.apply(this::configureRepackaging)
.enableMemberValuePropagationAnnotations(enableMemberValuePropagationAnnotations)
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
index 9dd90f3..543dbf8 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithPackagePrivateFieldTypeTest.java
@@ -63,7 +63,6 @@
public static class IneligibleForRepackaging {
- @NeverPropagateValue
private static NonPublicKeptClass FIELD =
System.currentTimeMillis() > 0 ? new PublicSubClass() : null;
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassIndirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassIndirect.java
index 2319ca4..7190c3f 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassIndirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassIndirect.java
@@ -7,7 +7,6 @@
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoHorizontalClassMerging;
import com.android.tools.r8.NoStaticClassMerging;
-import com.android.tools.r8.NoVerticalClassMerging;
@NoHorizontalClassMerging
@NoStaticClassMerging
@@ -18,7 +17,8 @@
Helper.test();
}
- @NoVerticalClassMerging
+ @NoHorizontalClassMerging
+ @NoStaticClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/resolution/InvokeDefaultMethodViaStaticTest.java b/src/test/java/com/android/tools/r8/resolution/InvokeDefaultMethodViaStaticTest.java
index 2080b42..37f328e 100644
--- a/src/test/java/com/android/tools/r8/resolution/InvokeDefaultMethodViaStaticTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/InvokeDefaultMethodViaStaticTest.java
@@ -6,7 +6,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.resolution.invokestaticinterfacedefault.InterfaceDump;
import com.android.tools.r8.resolution.invokestaticinterfacedefault.MainDump;
import com.google.common.collect.ImmutableList;
@@ -35,34 +34,20 @@
@Test
public void testReference() throws Exception {
- TestRunResult<?> result =
- testForRuntime(parameters)
- .addProgramClassFileData(CLASSES)
- .run(parameters.getRuntime(), "Main");
- if (parameters.isDexRuntime()
- && parameters.getApiLevel().isLessThan(apiLevelWithDefaultInterfaceMethodsSupport())) {
- // TODO(b/167535447): Desugaring should preserve the error.
- result.assertFailureWithErrorThatThrows(NoSuchMethodError.class);
- } else {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- }
+ testForRuntime(parameters)
+ .addProgramClassFileData(CLASSES)
+ .run(parameters.getRuntime(), "Main")
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
@Test
public void testR8() throws Exception {
- TestRunResult<?> result =
- testForR8(parameters.getBackend())
- .addProgramClassFileData(CLASSES)
- .addKeepMainRule("Main")
- .setMinApi(parameters.getApiLevel())
- .addOptionsModification(o -> o.testing.allowInvokeErrors = true)
- .run(parameters.getRuntime(), "Main");
- if (parameters.isDexRuntime()
- && parameters.getApiLevel().isLessThan(apiLevelWithDefaultInterfaceMethodsSupport())) {
- // TODO(b/167535447): Desugaring should preserve the error.
- result.assertFailureWithErrorThatThrows(NoClassDefFoundError.class);
- } else {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- }
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(CLASSES)
+ .addKeepMainRule("Main")
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(o -> o.testing.allowInvokeErrors = true)
+ .run(parameters.getRuntime(), "Main")
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
}
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 fef40af..8edefd8 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleStaticTargetLookupTestRunner.java
@@ -17,6 +17,7 @@
import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -65,7 +66,8 @@
assertThat(clazz, isPresent());
assertThat(main, isPresent());
assertEquals(keepFoo, staticFoo.isPresent());
- assertEquals(keepFoo, main.streamInstructions().anyMatch(i -> i.isInvokeStatic()));
+ assertEquals(
+ keepFoo, main.streamInstructions().anyMatch(InstructionSubject::isInvokeStatic));
});
}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
index 5da5b2d..1d6dc16 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
@@ -44,6 +44,7 @@
public static class B extends A implements I {}
public static class C extends B {
+ @Override
public void f() {
System.out.println("Called C.f");
}
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 3f7568a..425f3b0 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
@@ -11,14 +11,15 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.graph.ResolutionResult.NoSuchMethodResult;
import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
@@ -108,15 +109,15 @@
Class<?> declaredClass = symbolicReferenceIsDefiningType ? definingClass : A.class;
Class<?> callerClass = A.class;
- AppView<AppInfoWithLiveness> appView = getAppView();
- AppInfoWithLiveness appInfo = appView.appInfo();
+ AppView<AppInfoWithClassHierarchy> appView = getAppView();
+ AppInfoWithClassHierarchy appInfo = appView.appInfo();
- DexProgramClass definingClassDefinition = getDexProgramClass(definingClass, appInfo);
- DexProgramClass declaredClassDefinition = getDexProgramClass(declaredClass, appInfo);
- DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appInfo);
+ DexProgramClass definingClassDefinition = getDexProgramClass(definingClass, appView);
+ DexProgramClass declaredClassDefinition = getDexProgramClass(declaredClass, appView);
+ DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appView);
- DexMethod method = getTargetMethodSignature(declaredClass, appInfo);
- assertCallingClassCallsTarget(callerClass, appInfo, method);
+ DexMethod method = getTargetMethodSignature(declaredClass, appView.dexItemFactory());
+ assertCallingClassCallsTarget(callerClass, appView, method);
// Resolve the method from the point of the declared holder.
assertEquals(method.holder, declaredClassDefinition.type);
@@ -136,7 +137,7 @@
DexClassAndMethod targetSuper =
resolutionResult.lookupInvokeSuperTarget(callerClassDefinition, appInfo);
if (inSameNest) {
- assertEquals(definingClassDefinition.type, targetSpecial.getHolderType());
+ assertEquals(definingClassDefinition.getType(), targetSpecial.getHolderType());
assertEquals(targetSpecial.getReference(), targetSuper.getReference());
} else {
assertNull(targetSpecial);
@@ -145,30 +146,30 @@
}
private void assertCallingClassCallsTarget(
- Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod target) {
- CodeInspector inspector = new CodeInspector(appInfo.app());
+ Class<?> callerClass, AppView<?> appView, DexMethod target) {
+ CodeInspector inspector = new CodeInspector(appView.appInfo().app());
MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
assertTrue(
foo.streamInstructions().anyMatch(i -> i.isInvokeSpecial() && i.getMethod() == target));
}
- private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppInfoWithLiveness appInfo) {
+ private DexMethod getTargetMethodSignature(
+ Class<?> declaredClass, DexItemFactory dexItemFactory) {
return buildMethod(
Reference.method(Reference.classFromClass(declaredClass), "bar", ImmutableList.of(), null),
- appInfo.dexItemFactory());
+ dexItemFactory);
}
- private DexProgramClass getDexProgramClass(Class<?> clazz, AppInfoWithLiveness appInfo) {
- return appInfo.definitionFor(buildType(clazz, appInfo.dexItemFactory())).asProgramClass();
+ private DexProgramClass getDexProgramClass(Class<?> clazz, AppView<?> appView) {
+ return appView.definitionFor(buildType(clazz, appView.dexItemFactory())).asProgramClass();
}
- private AppView<AppInfoWithLiveness> getAppView() throws Exception {
- return computeAppViewWithLiveness(
+ private AppView<AppInfoWithClassHierarchy> getAppView() throws Exception {
+ return computeAppViewWithClassHierachy(
buildClasses(getClasses())
.addClassProgramData(getTransformedClasses())
.addLibraryFile(TestBase.runtimeJar(parameters.getBackend()))
- .build(),
- Main.class);
+ .build());
}
@Test
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 364014c..07487ec 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
@@ -171,6 +171,10 @@
.addProgramClassFileData(getTransformedClasses())
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(Main.class)
+ .applyIf(
+ !parameters.canUseDefaultAndStaticInterfaceMethods()
+ && !symbolicReferenceIsDefiningType,
+ builder -> builder.addDontWarnCompanionClass(J.class))
.run(parameters.getRuntime(), Main.class)
.apply(result -> checkExpectedResult(result, true));
}
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 5a3d01e..c6a2dbf 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
@@ -11,6 +11,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexClassAndMethod;
@@ -18,7 +19,6 @@
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.OptionalBool;
@@ -82,16 +82,16 @@
Class<?> declaredClass = A.class;
Class<?> callerClass = B.class;
- AppView<AppInfoWithLiveness> appView = getAppView();
- AppInfoWithLiveness appInfo = appView.appInfo();
+ AppView<AppInfoWithClassHierarchy> appView = getAppView();
+ AppInfoWithClassHierarchy appInfo = appView.appInfo();
- DexClass definingClassDefinition = getDexProgramClass(definingClass, appInfo);
- DexClass declaredClassDefinition = getDexProgramClass(declaredClass, appInfo);
- DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appInfo);
+ DexClass definingClassDefinition = getDexProgramClass(definingClass, appView);
+ DexClass declaredClassDefinition = getDexProgramClass(declaredClass, appView);
+ DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appView);
- DexMethod method = getTargetMethodSignature(declaredClass, appInfo);
+ DexMethod method = getTargetMethodSignature(declaredClass, appView);
- assertCallingClassCallsTarget(callerClass, appInfo, method);
+ assertCallingClassCallsTarget(callerClass, appView, method);
// Resolve the method from the point of the declared holder.
assertEquals(method.holder, declaredClassDefinition.type);
@@ -121,29 +121,28 @@
}
private void assertCallingClassCallsTarget(
- Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod target) {
- CodeInspector inspector = new CodeInspector(appInfo.app());
+ Class<?> callerClass, AppView<?> appView, DexMethod target) {
+ CodeInspector inspector = new CodeInspector(appView.appInfo().app());
MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
assertTrue(
foo.streamInstructions().anyMatch(i -> i.isInvokeSpecial() && i.getMethod() == target));
}
- private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppInfoWithLiveness appInfo) {
+ private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppView<?> appView) {
return buildMethod(
Reference.method(Reference.classFromClass(declaredClass), "bar", ImmutableList.of(), null),
- appInfo.dexItemFactory());
+ appView.dexItemFactory());
}
- private DexProgramClass getDexProgramClass(Class<?> definingClass, AppInfoWithLiveness appInfo) {
- return appInfo
- .definitionFor(buildType(definingClass, appInfo.dexItemFactory()))
+ private DexProgramClass getDexProgramClass(Class<?> definingClass, AppView<?> appView) {
+ return appView
+ .definitionFor(buildType(definingClass, appView.dexItemFactory()))
.asProgramClass();
}
- private AppView<AppInfoWithLiveness> getAppView() throws Exception {
- return computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
- Main.class);
+ private AppView<AppInfoWithClassHierarchy> getAppView() throws Exception {
+ return computeAppViewWithClassHierachy(
+ buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build());
}
@Test
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 b291f91..ce6f4d7 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
@@ -11,6 +11,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexClassAndMethod;
@@ -19,7 +20,6 @@
import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.graph.ResolutionResult.IllegalAccessOrNoSuchMethodResult;
import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -107,16 +107,16 @@
Class<?> declaredClass = symbolicReferenceIsDefiningType ? definingClass : B.class;
Class<?> callerClass = C.class;
- AppView<AppInfoWithLiveness> appView = getAppView();
- AppInfoWithLiveness appInfo = appView.appInfo();
+ AppView<AppInfoWithClassHierarchy> appView = getAppView();
+ AppInfoWithClassHierarchy appInfo = appView.appInfo();
- DexClass definingClassDefinition = getDexProgramClass(definingClass, appInfo);
- DexClass declaredClassDefinition = getDexProgramClass(declaredClass, appInfo);
- DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appInfo);
+ DexClass definingClassDefinition = getDexProgramClass(definingClass, appView);
+ DexClass declaredClassDefinition = getDexProgramClass(declaredClass, appView);
+ DexProgramClass callerClassDefinition = getDexProgramClass(callerClass, appView);
- DexMethod method = getTargetMethodSignature(declaredClass, appInfo);
+ DexMethod method = getTargetMethodSignature(declaredClass, appView);
- assertCallingClassCallsTarget(callerClass, appInfo, method);
+ assertCallingClassCallsTarget(callerClass, appView, method);
// Resolve the method from the point of the declared holder.
assertEquals(method.holder, declaredClassDefinition.type);
@@ -153,27 +153,26 @@
}
private void assertCallingClassCallsTarget(
- Class<?> callerClass, AppInfoWithLiveness appInfo, DexMethod target) {
- CodeInspector inspector = new CodeInspector(appInfo.app());
+ Class<?> callerClass, AppView<?> appView, DexMethod target) {
+ CodeInspector inspector = new CodeInspector(appView.appInfo().app());
MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
assertTrue(
foo.streamInstructions().anyMatch(i -> i.isInvokeSpecial() && i.getMethod() == target));
}
- private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppInfoWithLiveness appInfo) {
+ private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppView<?> appView) {
return buildMethod(
Reference.method(Reference.classFromClass(declaredClass), "bar", ImmutableList.of(), null),
- appInfo.dexItemFactory());
+ appView.dexItemFactory());
}
- private DexProgramClass getDexProgramClass(Class<?> clazz, AppInfoWithLiveness appInfo) {
- return appInfo.definitionFor(buildType(clazz, appInfo.dexItemFactory())).asProgramClass();
+ private DexProgramClass getDexProgramClass(Class<?> clazz, AppView<?> appView) {
+ return appView.definitionFor(buildType(clazz, appView.dexItemFactory())).asProgramClass();
}
- private AppView<AppInfoWithLiveness> getAppView() throws Exception {
- return computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
- Main.class);
+ private AppView<AppInfoWithClassHierarchy> getAppView() throws Exception {
+ return computeAppViewWithClassHierachy(
+ buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build());
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
index 3215f17..8f800f6 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
@@ -93,7 +93,6 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @FunctionalInterface
@NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
index 77fa9d8..169c255 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
@@ -89,7 +89,6 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @FunctionalInterface
@NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
index 70a350f..16c1401 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
@@ -86,6 +86,9 @@
.addProgramClasses(I.class, J.class, Main.class)
.addProgramClassFileData(setAImplementsIAndJ())
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
@@ -131,6 +134,9 @@
.addProgramClasses(I.class, J.class, K.class, Main.class)
.addProgramClassFileData(setAimplementsIandK())
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
index 5422f9b..958e785 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
@@ -90,7 +90,6 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @FunctionalInterface
@NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
index 0daaa44..1e23ae3 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
@@ -86,6 +86,9 @@
.addProgramClasses(I.class, J.class, Main.class)
.addProgramClassFileData(setAImplementsIAndJ())
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
index 3566d3a..bc35d2b 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
@@ -232,7 +232,7 @@
// ----- Program -----
// B extends A { } <-- initial
AppView<AppInfoWithClassHierarchy> appView =
- computeAppViewWithSubtyping(
+ computeAppViewWithClassHierachy(
buildClasses(Collections.singletonList(B.class), Arrays.asList(A.class, I.class))
.build());
AppInfoWithClassHierarchy appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
index e5904db..00f9b0b 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
@@ -11,8 +11,6 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -101,6 +99,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(MyViewModel.class, Main.class, ViewModel.class, ViewModelRunner.class)
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
@@ -146,6 +145,7 @@
.addProgramClasses(MyViewModel.class, ViewModel.class, ViewModelRunner.class)
.addProgramClassFileData(getModifiedMainWithIllegalInvokeToViewModelClear())
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertFailureWithErrorThatThrows(IllegalAccessError.class);
@@ -198,6 +198,7 @@
.addProgramClasses(MyViewModel.class, ViewModel.class, Main.class)
.addProgramClassFileData(getModifiedViewModelRunnerWithDirectMyViewModelTarget())
.addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(AMBIGUOUS_EXPECTED_OUTPUT);
@@ -238,10 +239,8 @@
.transform();
}
- @NeverClassInline
public static class MyViewModel extends ViewModel {
- @NeverInline
public void clear() {
System.out.println("MyViewModel.clear()");
}
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 3cabc0e..6973f6b 100644
--- a/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.AlwaysInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverPropagateValue;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -110,6 +109,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InlineWithoutNullCheckTest.class)
.addKeepMainRule(TestClassForInlineMethod.class)
+ .enableAlwaysInliningAnnotations()
.enableInliningAnnotations()
.addKeepAttributes(ProguardKeepAttributes.SOURCE_FILE)
.setMinApi(parameters.getApiLevel())
@@ -137,6 +137,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InlineWithoutNullCheckTest.class)
.addKeepMainRule(TestClassForInlineField.class)
+ .enableAlwaysInliningAnnotations()
.enableInliningAnnotations()
.addKeepAttributes(ProguardKeepAttributes.SOURCE_FILE)
.setMinApi(parameters.getApiLevel())
@@ -165,6 +166,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InlineWithoutNullCheckTest.class)
.addKeepMainRule(TestClassForInlineStaticField.class)
+ .enableAlwaysInliningAnnotations()
.enableInliningAnnotations()
.addKeepAttributes(ProguardKeepAttributes.SOURCE_FILE)
.setMinApi(parameters.getApiLevel())
@@ -232,7 +234,7 @@
}
static class A {
- @NeverPropagateValue Result result;
+ Result result;
A(Result result) {
this.result = result;
@@ -260,8 +262,8 @@
}
static class Result {
- @NeverPropagateValue int x = 1;
- @NeverPropagateValue static int y = 1;
+ int x = 1;
+ static int y = 1;
@AlwaysInline
int methodWhichAccessInstanceMethod() {
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 274b990..94e1e1a 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -91,6 +91,7 @@
testForR8(parameters.getBackend())
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
.addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addDontWarnJetBrainsNotNullAnnotation()
.addKeepAttributes("SourceFile", "LineNumberTable")
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(MAIN)
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 d22a979..3827c26 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -109,6 +109,7 @@
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -139,6 +140,7 @@
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -172,6 +174,7 @@
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -204,6 +207,7 @@
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
+ .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
diff --git a/src/test/java/com/android/tools/r8/rewrite/ServiceLoaderMultipleCallsTest.java b/src/test/java/com/android/tools/r8/rewrite/ServiceLoaderMultipleCallsTest.java
index 688a96f..fd1a05a 100644
--- a/src/test/java/com/android/tools/r8/rewrite/ServiceLoaderMultipleCallsTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/ServiceLoaderMultipleCallsTest.java
@@ -4,11 +4,10 @@
package com.android.tools.r8.rewrite;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertNull;
import static junit.framework.TestCase.assertTrue;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.DataEntryResource;
@@ -20,6 +19,7 @@
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import java.io.IOException;
import java.nio.file.Path;
@@ -109,11 +109,18 @@
inspector -> {
// Check that we have actually rewritten the calls to ServiceLoader.load.
assertEquals(0, getServiceLoaderLoads(inspector, MainRunner.class));
- // Check that the synthesize service loader class holds two methods, one for each
- // context.
- ClassSubject serviceLoaderMethods = inspector.clazz("$$ServiceLoaderMethods");
- assertThat(serviceLoaderMethods, isPresent());
- assertEquals(2, serviceLoaderMethods.allMethods().size());
+ // Check the synthesize service loader method is a single shared method.
+ // Due to minification we just check there is only a single synthetic class with a
+ // single static method.
+ boolean found = false;
+ for (FoundClassSubject clazz : inspector.allClasses()) {
+ if (clazz.isSynthetic()) {
+ assertFalse(found);
+ found = true;
+ assertEquals(1, clazz.allMethods().size());
+ clazz.forAllMethods(m -> assertTrue(m.isStatic()));
+ }
+ }
});
// Check that we have removed the service configuration from META-INF/services.
diff --git a/src/test/java/com/android/tools/r8/rewrite/enums/EnumInvalidValuesLengthTest.java b/src/test/java/com/android/tools/r8/rewrite/enums/EnumInvalidValuesLengthTest.java
index ead99d1..2636944 100644
--- a/src/test/java/com/android/tools/r8/rewrite/enums/EnumInvalidValuesLengthTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/enums/EnumInvalidValuesLengthTest.java
@@ -36,6 +36,7 @@
.addKeepMainRule(EnumInvalidValuesLengthTest.Main.class)
.addProgramClasses(EnumInvalidValuesLengthTest.Main.class)
.addProgramClassFileData(transformValues(MyEnum.class))
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), EnumInvalidValuesLengthTest.Main.class)
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 ae4947a..7733b23 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
@@ -57,6 +57,7 @@
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(Ordinals.class)
.addKeepMainRule(Ordinals.class)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.enableSideEffectAnnotations()
.addOptionsModification(this::configure)
@@ -105,6 +106,7 @@
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(Names.class)
.addKeepMainRule(Names.class)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.enableSideEffectAnnotations()
.addOptionsModification(this::configure)
@@ -150,6 +152,7 @@
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(ToStrings.class)
.addKeepMainRule(ToStrings.class)
+ .enableForceInliningAnnotations()
.enableInliningAnnotations()
.enableSideEffectAnnotations()
.addOptionsModification(this::configure)
diff --git a/src/test/java/com/android/tools/r8/rewrite/enums/EnumSideEffect.java b/src/test/java/com/android/tools/r8/rewrite/enums/EnumSideEffect.java
index a0e59b3..2d1b018 100644
--- a/src/test/java/com/android/tools/r8/rewrite/enums/EnumSideEffect.java
+++ b/src/test/java/com/android/tools/r8/rewrite/enums/EnumSideEffect.java
@@ -39,6 +39,7 @@
.addKeepMainRule(Main.class)
.enableInliningAnnotations()
.addInnerClasses(EnumSideEffect.class)
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassTest.java b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassTest.java
index ee99ea1..5bcfdb8 100644
--- a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.rewrite.serviceloaders;
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@@ -55,10 +54,11 @@
AppServices.SERVICE_DIRECTORY_NAME + Service.class.getTypeName(),
Origin.unknown()))
.addOptionsModification(o -> o.dataResourceConsumer = dataResourceConsumer)
+ .addDontWarn(ServiceImpl.class)
.allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.compile()
- .inspectDiagnosticMessages(this::inspectDiagnosticMessages)
+ .inspectDiagnosticMessages(this::inspectDiagnosticMessagesWithDontWarn)
.addRunClasspathClasses(Service.class, ServiceImpl.class)
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithEmptyOutput();
@@ -80,26 +80,39 @@
AppServices.SERVICE_DIRECTORY_NAME + Service.class.getTypeName(),
Origin.unknown()))
.run()
- .inspectDiagnosticMessages(this::inspectDiagnosticMessages);
+ .inspectDiagnosticMessages(this::inspectDiagnosticMessagesWithoutDontWarn);
}
- private void inspectDiagnosticMessages(TestDiagnosticMessages inspector) {
- inspector.assertWarningsCount(2);
- inspector.assertAllWarningsMatch(
- diagnosticMessage(
- anyOf(
+ private void inspectDiagnosticMessagesWithDontWarn(TestDiagnosticMessages diagnostics) {
+ diagnostics
+ .assertOnlyWarnings()
+ .assertWarningsMatch(
+ diagnosticMessage(
containsString(
"Unexpected reference to missing service class: "
+ AppServices.SERVICE_DIRECTORY_NAME
+ Service.class.getTypeName()
- + "."),
+ + ".")));
+ }
+
+ private void inspectDiagnosticMessagesWithoutDontWarn(TestDiagnosticMessages inspector) {
+ inspector
+ .assertOnlyWarnings()
+ .assertWarningsMatch(
+ diagnosticMessage(
+ containsString(
+ "Unexpected reference to missing service class: "
+ + AppServices.SERVICE_DIRECTORY_NAME
+ + Service.class.getTypeName()
+ + ".")),
+ diagnosticMessage(
containsString(
"Unexpected reference to missing service implementation class in "
+ AppServices.SERVICE_DIRECTORY_NAME
+ Service.class.getTypeName()
+ ": "
+ ServiceImpl.class.getTypeName()
- + "."))));
+ + ".")));
}
private void inspectResource(List<String> contents) {
diff --git a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassWithFeatureTest.java b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassWithFeatureTest.java
index f36c122..be5dfb6 100644
--- a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassWithFeatureTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceClassWithFeatureTest.java
@@ -38,7 +38,7 @@
.addProgramClasses(TestClass.class, ServiceImpl.class)
.addKeepMainRule(TestClass.class)
.addKeepClassAndMembersRules(FeatureClass.class)
- .addKeepRules("-dontwarn " + Service.class.getTypeName())
+ .addDontWarn(Service.class.getTypeName())
.addDataEntryResources(
DataEntryResource.fromBytes(
StringUtils.lines("java.lang.Object").getBytes(),
diff --git a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassTest.java b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassTest.java
index 9039c50..ca17780 100644
--- a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassTest.java
@@ -4,15 +4,12 @@
package com.android.tools.r8.rewrite.serviceloaders;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import com.android.tools.r8.DataEntryResource;
-import com.android.tools.r8.NeverInline;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -59,6 +56,7 @@
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, Service.class)
+ .addDontWarn(ServiceImpl.class)
.addKeepMainRule(TestClass.class)
.addKeepClassAndMembersRulesWithAllowObfuscation(Service.class)
.addDataEntryResources(
@@ -72,22 +70,8 @@
new DataResourceConsumerForTesting(options.dataResourceConsumer));
options.dataResourceConsumer = dataResourceConsumer.get();
})
- .allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
- .compile()
- .inspectDiagnosticMessages(
- inspector -> {
- inspector.assertWarningsCount(1);
- inspector.assertAllWarningsMatch(
- diagnosticMessage(
- containsString(
- "Unexpected reference to missing service implementation class in "
- + AppServices.SERVICE_DIRECTORY_NAME
- + Service.class.getTypeName()
- + ": "
- + ServiceImpl.class.getTypeName()
- + ".")));
- });
+ .compile();
CodeInspector inspector = compileResult.inspector();
ClassSubject serviceClassSubject = inspector.clazz(Service.class);
@@ -171,7 +155,6 @@
public static class ServiceImpl implements Service {
@Override
- @NeverInline
public void greet() {
System.out.println("Hello world!");
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassWithFeatureTest.java b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassWithFeatureTest.java
index b3f120c..a3aea84 100644
--- a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassWithFeatureTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/MissingServiceImplementationClassWithFeatureTest.java
@@ -4,8 +4,6 @@
package com.android.tools.r8.rewrite.serviceloaders;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static org.hamcrest.CoreMatchers.containsString;
import com.android.tools.r8.DataEntryResource;
import com.android.tools.r8.TestBase;
@@ -40,6 +38,7 @@
public void testR8() throws Exception {
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, Service.class)
+ .addDontWarn("MissingClass")
.addKeepMainRule(TestClass.class)
.addKeepClassAndMembersRules(FeatureClass.class)
.addDataEntryResources(
@@ -48,20 +47,8 @@
AppServices.SERVICE_DIRECTORY_NAME + Service.class.getTypeName(),
Origin.unknown()))
.addFeatureSplit(FeatureClass.class)
- .allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
- .compile()
- .inspectDiagnosticMessages(
- inspector -> {
- inspector.assertWarningsCount(1);
- inspector.assertAllWarningsMatch(
- diagnosticMessage(
- containsString(
- "Unexpected reference to missing service implementation class in "
- + AppServices.SERVICE_DIRECTORY_NAME
- + Service.class.getTypeName()
- + ": MissingClass.")));
- });
+ .compile();
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/ServiceWithoutResourceFileAtCompileTimeTest.java b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/ServiceWithoutResourceFileAtCompileTimeTest.java
index 1ea55b8..9f5eada 100644
--- a/src/test/java/com/android/tools/r8/rewrite/serviceloaders/ServiceWithoutResourceFileAtCompileTimeTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/serviceloaders/ServiceWithoutResourceFileAtCompileTimeTest.java
@@ -69,6 +69,7 @@
.addClasspathClasses(Service.class)
.addKeepAllClassesRule()
.addApplyMapping(compileResult.getProguardMap())
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(
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
new file mode 100644
index 0000000..0f3f2cc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/rewrite/switches/MaxIntSwitchTest.java
@@ -0,0 +1,90 @@
+// 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.rewrite.switches;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MaxIntSwitchTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final CompilationMode mode;
+
+ @Parameterized.Parameters(name = "{0}, mode = {1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withDexRuntimes().withAllApiLevels().build(), CompilationMode.values());
+ }
+
+ // See b/177790310 for details.
+ public MaxIntSwitchTest(TestParameters parameters, CompilationMode mode) {
+ this.parameters = parameters;
+ this.mode = mode;
+ }
+
+ private void checkResult(TestRunResult<?> result) {
+ if (parameters.getDexRuntimeVersion().isOlderThanOrEqual(Version.V4_0_4)) {
+ result.assertFailureWithErrorThatThrows(AssertionError.class);
+ } else {
+ result.assertSuccessWithOutputLines("good");
+ }
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addInnerClasses(this.getClass())
+ .setMinApi(parameters.getApiLevel())
+ .setMode(mode)
+ .run(parameters.getRuntime(), TestClass.class)
+ .apply(this::checkResult);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(this.getClass())
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMemberValuePropagationAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .setMode(mode)
+ .run(parameters.getRuntime(), TestClass.class)
+ .apply(this::checkResult);
+ }
+
+ static class TestClass {
+ @NeverInline
+ @NeverPropagateValue
+ public static void f(int i) {
+ switch (i) {
+ case 0x7ffffffd:
+ System.out.println("a");
+ break;
+ case 0x7ffffffe:
+ System.out.println("b");
+ break;
+ case 0x7fffffff:
+ System.out.println("good");
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ public static void main(String[] args) {
+ f(0x7fffffff);
+ }
+ }
+}
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 b5aba75..993a658 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepAnnotatedMemberTest.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.android.tools.r8.utils.graphinspector.GraphInspector;
@@ -73,6 +74,9 @@
testForR8(Backend.CF)
.addProgramFiles(R8_JAR)
.addKeepRules("-keep class * { @" + PRESENT_ANNOTATION + " *; }")
+ .addDontWarnGoogle()
+ .addDontWarnJavax()
+ .addDontWarn("org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement")
.compileWithExpectedDiagnostics(
diagnostics ->
diagnostics.assertErrorsMatch(diagnosticException(AssertionError.class)));
@@ -85,6 +89,9 @@
.addProgramFiles(R8_JAR)
.addKeepRules(
"-keep class *", "-keepclassmembers class * { @" + PRESENT_ANNOTATION + " *; }")
+ .addDontWarnGoogle()
+ .addDontWarnJavax()
+ .addDontWarn("org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement")
.compile();
}
@@ -103,6 +110,9 @@
testForR8(Backend.CF)
.addProgramFiles(R8_JAR)
.addKeepRules("-keepclasseswithmembers class * { @" + PRESENT_ANNOTATION + " *** *(...); }")
+ .addDontWarnGoogle()
+ .addDontWarnJavax()
+ .addDontWarn("org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement")
.compile()
.inspect(
inspector -> {
@@ -192,6 +202,8 @@
// TODO(b/132318609): Remove keep annotation once fixed.
.addKeepClassRules(PRESENT_ANNOTATION)
.addKeepRules("-keepclassmembers class * { @" + PRESENT_ANNOTATION + " *** *(...); }")
+ .addDontWarnGoogle()
+ .addDontWarnJavaxNullableAnnotation()
.compile()
.graphInspector();
@@ -208,6 +220,8 @@
+ "-keepclassmembers class <1> { @"
+ PRESENT_ANNOTATION
+ " *** *(...); }")
+ .addDontWarnGoogle()
+ .addDontWarnJavaxNullableAnnotation()
.compile()
.graphInspector();
assertRetainedClassesEqual(referenceInspector, ifThenKeepClassMembersInspector, false, false);
@@ -225,6 +239,8 @@
+ "-keepclasseswithmembers class <1> { @"
+ PRESENT_ANNOTATION
+ " *** *(...); }")
+ .addDontWarnGoogle()
+ .addDontWarnJavaxNullableAnnotation()
.compile()
.graphInspector();
assertRetainedClassesEqual(
@@ -245,6 +261,8 @@
+ "-keep class <1> { @"
+ PRESENT_ANNOTATION
+ " *** <2>(...); }")
+ .addDontWarnGoogle()
+ .addDontWarnJavaxNullableAnnotation()
.compile()
.graphInspector();
// TODO(b/159418523): Should the reference be equal to the result with the conditional rule?
@@ -259,12 +277,12 @@
Set<String> referenceClasses =
new TreeSet<>(
referenceResult.codeInspector().allClasses().stream()
- .map(c -> c.getOriginalName())
+ .map(FoundClassSubject::getOriginalName)
.collect(Collectors.toSet()));
Set<String> conditionalClasses =
conditionalResult.codeInspector().allClasses().stream()
- .map(c -> c.getOriginalName())
+ .map(FoundClassSubject::getOriginalName)
.collect(Collectors.toSet());
{
SetView<String> notInReference = Sets.difference(conditionalClasses, referenceClasses);
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java
index 7d68070..331eb12 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java
@@ -87,14 +87,12 @@
}
}
- @FunctionalInterface
@NoVerticalClassMerging
interface I {
Iterator<Object> iterator();
}
- @FunctionalInterface
@NoVerticalClassMerging
interface J extends Iterable<Object> {
diff --git a/src/test/java/com/android/tools/r8/shaking/MissingInterfaceTest.java b/src/test/java/com/android/tools/r8/shaking/MissingInterfaceTest.java
index 7254ee6..617676f 100644
--- a/src/test/java/com/android/tools/r8/shaking/MissingInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/MissingInterfaceTest.java
@@ -35,11 +35,10 @@
public void test_missingInterface() throws Exception {
testForR8(parameters.getBackend())
.addProgramClasses(TestClassForB112849320.class)
+ .addDontWarn(GoingToBeMissed.class)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(TestClassForB112849320.class)
.addOptionsModification(options -> options.enableInlining = false)
- .allowDiagnosticWarningMessages(
- parameters.isCfRuntime() || !parameters.canUseDefaultAndStaticInterfaceMethods())
.compile()
.addRunClasspathFiles(
buildOnDexRuntime(
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 cd153f2..74b7c8a 100644
--- a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.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.utils.AndroidApiLevel;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
@@ -68,8 +67,7 @@
.addClasspathClasses(Interface.class)
.addLibraryFiles(TestBase.runtimeJar(parameters.getBackend()))
.addKeepAllClassesRule()
- .allowDiagnosticWarningMessages(
- parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+ .addDontWarn(A.class)
.setMinApi(parameters.getApiLevel())
.compile()
.addRunClasspathFiles(libraryCompileResult.writeToZip())
@@ -79,8 +77,7 @@
codeInspector.allClasses().stream()
.anyMatch(
c -> {
- if (c.getOriginalName()
- .contains("-$$Lambda$PreserveDesugaredLambdaTest$Main")) {
+ if (c.isSynthesizedJavaLambdaClass()) {
assertThat(c.uniqueMethodWithName("computeTheFoo"), isPresent());
return true;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java b/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
index 9c88b7f..3d2e137 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintUsageTest.java
@@ -7,8 +7,10 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.PrintUsageTest.PrintUsageInspector.ClassSubject;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.ListUtils;
import com.google.common.collect.ImmutableList;
import java.io.File;
@@ -38,18 +40,18 @@
private static final String PRINT_USAGE_FILE_SUFFIX = "-print-usage.txt";
- private final Backend backend;
+ private final TestParameters parameters;
private final String test;
private final String programFile;
private final List<String> keepRulesFiles;
private final Consumer<PrintUsageInspector> inspection;
public PrintUsageTest(
- Backend backend,
+ TestParameters parameters,
String test,
List<String> keepRulesFiles,
Consumer<PrintUsageInspector> inspection) {
- this.backend = backend;
+ this.parameters = parameters;
this.test = test;
this.programFile = ToolHelper.EXAMPLES_BUILD_DIR + test + ".jar";
this.keepRulesFiles = keepRulesFiles;
@@ -59,13 +61,19 @@
@Before
public void runR8andGetPrintUsage() throws Exception {
Path out = temp.getRoot().toPath();
- testForR8(backend)
+ testForR8(parameters.getBackend())
.addProgramFiles(Paths.get(programFile))
.addKeepRuleFiles(ListUtils.map(keepRulesFiles, Paths::get))
.addKeepRules("-printusage " + out.resolve(test + PRINT_USAGE_FILE_SUFFIX))
+ .applyIf(
+ test.equals("shaking12")
+ && parameters.isDexRuntime()
+ && parameters.getApiLevel().isLessThan(AndroidApiLevel.K),
+ builder -> builder.addDontWarn(ReflectiveOperationException.class))
// Disable inlining to make this test not depend on inlining decisions.
.addOptionsModification(o -> o.enableInlining = false)
.enableProguardTestOptions()
+ .setMinApi(parameters.getApiLevel())
.compile();
}
@@ -79,7 +87,7 @@
}
}
- @Parameters(name = "test: {0} keep: {1}")
+ @Parameters(name = "{0}, test: {1} keep: {2}")
public static Collection<Object[]> data() {
List<String> tests = Arrays.asList(
"shaking1", "shaking2", "shaking4", "shaking8", "shaking9", "shaking12");
@@ -93,7 +101,7 @@
inspections.put("shaking12:keep-rules-printusage.txt", PrintUsageTest::inspectShaking12);
List<Object[]> testCases = new ArrayList<>();
- for (Backend backend : ToolHelper.getBackends()) {
+ for (TestParameters parameters : getTestParameters().withAllRuntimesAndApiLevels().build()) {
Set<String> usedInspections = new HashSet<>();
for (String test : tests) {
File[] keepFiles = new File(ToolHelper.EXAMPLES_DIR + test)
@@ -103,8 +111,8 @@
Consumer<PrintUsageInspector> inspection =
getTestOptionalParameter(inspections, usedInspections, test, keepName);
if (inspection != null) {
- testCases.add(
- new Object[] {backend, test, ImmutableList.of(keepFile.getPath()), inspection});
+ testCases.add(
+ new Object[] {parameters, test, ImmutableList.of(keepFile.getPath()), inspection});
}
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
index c15fb48..b479f43 100644
--- a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
@@ -22,6 +22,7 @@
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
import com.android.tools.r8.graph.ClassAccessFlags;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
@@ -56,6 +57,7 @@
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Function;
+import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.stream.Collectors;
@@ -268,7 +270,7 @@
}
private void testDontXXX(
- String xxx, Function<ProguardConfiguration, ProguardClassFilter> pattern) {
+ String xxx, Function<ProguardConfiguration, Predicate<DexType>> matcherFactory) {
DexItemFactory dexItemFactory = new DexItemFactory();
ProguardConfigurationParser parser =
new ProguardConfigurationParser(dexItemFactory, reporter);
@@ -276,19 +278,20 @@
parser.parse(createConfigurationForTesting(ImmutableList.of(configuration)));
verifyParserEndsCleanly();
ProguardConfiguration config = parser.getConfig();
- assertFalse(pattern.apply(config).matches(dexItemFactory.createType("Lboobaz;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lboobar;")));
- assertFalse(pattern.apply(config).matches(dexItemFactory.createType("Lfoobar;")));
+ Predicate<DexType> matcher = matcherFactory.apply(config);
+ assertFalse(matcher.test(dexItemFactory.createType("Lboobaz;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lboobar;")));
+ assertFalse(matcher.test(dexItemFactory.createType("Lfoobar;")));
}
@Test
public void testDontXXX() {
- testDontXXX("warn", ProguardConfiguration::getDontWarnPatterns);
- testDontXXX("note", ProguardConfiguration::getDontNotePatterns);
+ testDontXXX("warn", config -> DontWarnConfiguration.create(config)::matches);
+ testDontXXX("note", config -> config.getDontNotePatterns()::matches);
}
private void testDontXXXMultiple(
- String xxx, Function<ProguardConfiguration, ProguardClassFilter> pattern) {
+ String xxx, Function<ProguardConfiguration, Predicate<DexType>> matcherFactory) {
DexItemFactory dexItemFactory = new DexItemFactory();
ProguardConfigurationParser parser =
new ProguardConfigurationParser(dexItemFactory, reporter);
@@ -298,20 +301,21 @@
parser.parse(createConfigurationForTesting(configuration));
verifyParserEndsCleanly();
ProguardConfiguration config = parser.getConfig();
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lfoo/Bar;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lfoo/bar7Bar;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lbar/Foo;")));
+ Predicate<DexType> matcher = matcherFactory.apply(config);
+ assertTrue(matcher.test(dexItemFactory.createType("Lfoo/Bar;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lfoo/bar7Bar;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lbar/Foo;")));
}
}
@Test
public void testDontWarnMultiple() {
- testDontXXXMultiple("warn", ProguardConfiguration::getDontWarnPatterns);
- testDontXXXMultiple("note", ProguardConfiguration::getDontNotePatterns);
+ testDontXXXMultiple("warn", config -> DontWarnConfiguration.create(config)::matches);
+ testDontXXXMultiple("note", config -> config.getDontNotePatterns()::matches);
}
private void testDontXXXAllExplicitly(
- String xxx, Function<ProguardConfiguration, ProguardClassFilter> pattern) {
+ String xxx, Function<ProguardConfiguration, Predicate<DexType>> matcherFactory) {
DexItemFactory dexItemFactory = new DexItemFactory();
ProguardConfigurationParser parser =
new ProguardConfigurationParser(dexItemFactory, reporter);
@@ -319,19 +323,20 @@
parser.parse(createConfigurationForTesting(ImmutableList.of(dontwarnAll)));
verifyParserEndsCleanly();
ProguardConfiguration config = parser.getConfig();
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lboobaz;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lboobar;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lfoobar;")));
+ Predicate<DexType> matcher = matcherFactory.apply(config);
+ assertTrue(matcher.test(dexItemFactory.createType("Lboobaz;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lboobar;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lfoobar;")));
}
@Test
public void testDontWarnAllExplicitly() {
- testDontXXXAllExplicitly("warn", ProguardConfiguration::getDontWarnPatterns);
- testDontXXXAllExplicitly("note", ProguardConfiguration::getDontNotePatterns);
+ testDontXXXAllExplicitly("warn", config -> DontWarnConfiguration.create(config)::matches);
+ testDontXXXAllExplicitly("note", config -> config.getDontNotePatterns()::matches);
}
private void testDontXXXAllImplicitly(
- String xxx, Function<ProguardConfiguration, ProguardClassFilter> pattern) {
+ String xxx, Function<ProguardConfiguration, Predicate<DexType>> matcherFactory) {
DexItemFactory dexItemFactory = new DexItemFactory();
ProguardConfigurationParser parser =
new ProguardConfigurationParser(dexItemFactory, reporter);
@@ -339,15 +344,16 @@
String otherOption = "-keep class *";
parser.parse(createConfigurationForTesting(ImmutableList.of(dontwarnAll, otherOption)));
ProguardConfiguration config = parser.getConfig();
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lboobaz;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lboobar;")));
- assertTrue(pattern.apply(config).matches(dexItemFactory.createType("Lfoobar;")));
+ Predicate<DexType> matcher = matcherFactory.apply(config);
+ assertTrue(matcher.test(dexItemFactory.createType("Lboobaz;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lboobar;")));
+ assertTrue(matcher.test(dexItemFactory.createType("Lfoobar;")));
}
@Test
public void testDontWarnAllImplicitly() {
- testDontXXXAllImplicitly("warn", ProguardConfiguration::getDontWarnPatterns);
- testDontXXXAllImplicitly("note", ProguardConfiguration::getDontNotePatterns);
+ testDontXXXAllImplicitly("warn", config -> DontWarnConfiguration.create(config)::matches);
+ testDontXXXAllImplicitly("note", config -> config.getDontNotePatterns()::matches);
}
@Test
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
index 96c6fb3..2f1a112 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
@@ -152,6 +152,24 @@
BiConsumer<CodeInspector, CodeInspector> dexComparator,
List<String> keepRulesFiles,
Consumer<InternalOptions> optionsConsumer,
+ ThrowableConsumer<R8FullTestBuilder> testBuilderConsumer)
+ throws Exception {
+ runTest(
+ inspection,
+ outputComparator,
+ dexComparator,
+ keepRulesFiles,
+ optionsConsumer,
+ testBuilderConsumer,
+ null);
+ }
+
+ protected void runTest(
+ ThrowingConsumer<CodeInspector, Exception> inspection,
+ BiConsumer<String, String> outputComparator,
+ BiConsumer<CodeInspector, CodeInspector> dexComparator,
+ List<String> keepRulesFiles,
+ Consumer<InternalOptions> optionsConsumer,
ThrowableConsumer<R8FullTestBuilder> testBuilderConsumer,
DiagnosticsConsumer diagnosticsConsumer)
throws Exception {
@@ -179,6 +197,9 @@
if (optionsConsumer != null) {
optionsConsumer.accept(options);
}
+ if (frontend == Frontend.DEX) {
+ options.testing.allowDexInputForTesting = true;
+ }
})
.allowStdoutMessages()
.applyIf(testBuilderConsumer != null, testBuilderConsumer);
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java
index 484fb10..9c98c6e 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java
@@ -91,6 +91,8 @@
.addKeepMainRule(MainWithNewB.class)
.addKeepClassAndMembersRules(Factory.class)
.addKeepAttributes("*Annotation*")
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MainWithNewB.class)
.assertSuccessWithOutputLines("Hello World!")
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 4e6adad..904c0cd 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
@@ -107,7 +107,9 @@
.addKeepAttributes("*Annotation*")
.addLibraryFiles(runtimeJar(parameters))
.addKeepClassAndMembersRules(Foo.class)
- .addKeepRules("-dontwarn " + LibraryAndMissingAnnotationsTest.class.getTypeName())
+ .applyIf(
+ builder.isProguardTestBuilder(),
+ ignore -> builder.addDontWarn(LibraryAndMissingAnnotationsTest.class))
.addKeepMainRule(mainClass)
.setMinApi(parameters.getApiLevel());
if (includeOnLibraryPath) {
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 3396686..13fbb3e 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
@@ -49,6 +49,7 @@
.addInnerClasses(ProgramAnnotationRemovalTest.class)
.addKeepMainRule(TestClass.class)
.addKeepAttributes("RuntimeVisibleAnnotations")
+ .enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class);
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 9c358e8..bc55c55 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
@@ -106,6 +106,7 @@
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepRules(KEEP_ANNOTATIONS)
.addKeepRules("-keep @interface " + ANNOTATION_NAME + " {", " *;", "}")
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -145,6 +146,7 @@
"-keep,allowobfuscation @interface " + ANNOTATION_NAME + " {",
" java.lang.String *f2();",
"}")
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -181,6 +183,7 @@
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepRules(KEEP_ANNOTATIONS)
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -216,6 +219,7 @@
.addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
+ .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
index 3b9c067..1112ccd 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
@@ -5,13 +5,11 @@
package com.android.tools.r8.shaking.annotations.b137392797;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -64,16 +62,14 @@
classWireFieldLabel(),
classTest(defaultEnumValueInAnnotation))
.addProgramClasses(TestClass.class)
+ .addDontWarnKotlin()
+ .addDontWarnJetBrainsAnnotations()
.addKeepClassAndMembersRules(
"com.squareup.wire.WireField", "com.squareup.demo.myapplication.Test")
.addKeepMainRule(TestClass.class)
.addKeepAttributes("*Annotation*")
- .allowDiagnosticWarningMessages(
- parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- containsString("required for default or static interface methods desugaring"))
.inspect(this::checkEnumUses)
.run(parameters.getRuntime(), TestClass.class, "com.squareup.demo.myapplication.Test")
.assertSuccessWithOutputLines(
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 0d9fa5e..b2f0964 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
@@ -53,12 +53,12 @@
}
// Simple mock implementation of class android.os.Build$VERSION with just the SDK_INT field.
- private Path mockAndroidRuntimeLibrary(int sdkInt) throws Exception {
+ private Path mockAndroidRuntimeLibrary(AndroidApiLevel apiLevel) throws Exception {
JasminBuilder builder = new JasminBuilder();
ClassBuilder classBuilder;
classBuilder = builder.addClass("android.os.Build$VERSION");
- classBuilder.addStaticFinalField("SDK_INT", "I", Integer.toString(sdkInt));
+ classBuilder.addStaticFinalField("SDK_INT", "I", Integer.toString(apiLevel.getLevel()));
classBuilder = builder.addClass("android.os.Native");
classBuilder.addStaticMethod("method", ImmutableList.of(), "V",
@@ -71,13 +71,12 @@
return writeToJar(builder);
}
- private Path buildMockAndroidRuntimeLibrary(AndroidApiLevel apiLevel) throws Exception {
+ private Path buildMockAndroidRuntimeLibrary(Path mockAndroidRuntimeLibrary) throws Exception {
// Build the mock library containing android.os.Build.VERSION with D8.
Path library = temp.newFolder().toPath().resolve("library.jar");
D8.run(
- D8Command
- .builder()
- .addProgramFiles(mockAndroidRuntimeLibrary(apiLevel.getLevel()))
+ D8Command.builder()
+ .addProgramFiles(mockAndroidRuntimeLibrary)
.setOutput(library, OutputMode.DexIndexed)
.build());
return library;
@@ -164,9 +163,11 @@
throws Exception {
assertTrue(runtimeApiLevel.getLevel() >= buildApiLevel.getLevel());
if (backend == Backend.DEX) {
+ Path androidRuntimeLibraryMock = mockAndroidRuntimeLibrary(runtimeApiLevel);
testForR8(backend)
.setMinApi(buildApiLevel)
.addProgramFiles(buildApp(nativeApiLevel))
+ .addClasspathFiles(androidRuntimeLibraryMock)
.enableProguardTestOptions()
.addKeepRules("-neverinline class " + compatLibraryClassName + " { *; }")
.addKeepMainRule(mainClassName)
@@ -177,20 +178,21 @@
syntheticProguardRules ->
checkSynthesizedRuleExpectation(syntheticProguardRules, synthesizedRule))
.inspect(inspector)
- .addRunClasspathFiles(ImmutableList.of(buildMockAndroidRuntimeLibrary(runtimeApiLevel)))
+ .addRunClasspathFiles(buildMockAndroidRuntimeLibrary(androidRuntimeLibraryMock))
.run(mainClassName)
.assertSuccessWithOutput(expectedOutput);
} else {
assert backend == Backend.CF;
+ Path androidRuntimeLibraryMock = mockAndroidRuntimeLibrary(AndroidApiLevel.D);
testForR8(backend)
.addProgramFiles(buildApp(nativeApiLevel))
.addKeepMainRule(mainClassName)
.addKeepRules(additionalKeepRules)
+ .addDontWarn("android.os.Build$VERSION", "android.os.Native")
.apply(configuration)
.compile()
.inspectSyntheticProguardRules(this::noSynthesizedRules)
- .addRunClasspathFiles(
- ImmutableList.of(mockAndroidRuntimeLibrary(AndroidApiLevel.D.getLevel())))
+ .addRunClasspathFiles(androidRuntimeLibraryMock)
.run(mainClassName)
.assertSuccessWithOutput(expectedResultForCompat(AndroidApiLevel.D));
}
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 1caf4f2..a913463 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
@@ -47,10 +47,10 @@
@Test
public void testProguard() throws ExecutionException, CompilationFailedException, IOException {
testForProguard()
- .addProgramClassesAndInnerClasses(Main.class)
+ .addInnerClasses(getClass())
.addKeepAllClassesRule()
.addKeepAttributes(keepAttributes)
- .addKeepRules("-dontwarn com.android.tools.r8.shaking.attributes.*")
+ .addDontWarn(KeepAttributesDotsTest.class)
.run(TestRuntime.getCheckedInJdk9(), Main.class)
.assertSuccessWithOutputLines("Hello World!")
.inspect(this::inspect);
@@ -59,7 +59,7 @@
@Test
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(Backend.CF)
- .addProgramClassesAndInnerClasses(Main.class)
+ .addInnerClasses(getClass())
.addKeepAttributes(keepAttributes)
.addKeepAllClassesRule()
.run(TestRuntime.getCheckedInJdk9(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesTest.java
index f298046..a314e96 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/KeepAttributesTest.java
@@ -27,11 +27,11 @@
@RunWith(Parameterized.class)
public class KeepAttributesTest extends TestBase {
- private static final Class CLASS = TestKeepAttributes.class;
+ private static final Class<?> CLASS = TestKeepAttributes.class;
@Parameters(name = "{0}")
public static TestParametersCollection parameters() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
private final TestParameters parameters;
@@ -111,7 +111,8 @@
.addProgramClassesAndInnerClasses(CLASS)
.addKeepAllClassesRule()
.addKeepRules(keepRules)
- .setMinApi(parameters.getRuntime())
+ .enableSideEffectAnnotations()
+ .setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), CLASS)
.inspector()
.clazz(CLASS)
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/EventEntity.java b/src/test/java/com/android/tools/r8/shaking/b134858535/EventEntity.java
new file mode 100644
index 0000000..0f92507
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/EventEntity.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.b134858535;
+
+public class EventEntity {}
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisher$bDump.java b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisher$bDump.java
index df725af..4836ae1 100644
--- a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisher$bDump.java
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisher$bDump.java
@@ -68,29 +68,33 @@
{
AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d2");
annotationVisitor1.visit(null, "<anonymous>");
- annotationVisitor1.visit(null, "Lio/reactivex/Flowable;");
+ annotationVisitor1.visit(null, "Lcom/android/tools/r8/shaking/b134858535/Flowable;");
annotationVisitor1.visit(null, "Lkotlin/Pair;");
- annotationVisitor1.visit(null, "Lcom/permutive/android/event/db/model/EventEntity;");
+ annotationVisitor1.visit(null, "Lcom/android/tools/r8/shaking/b134858535/EventEntity;");
annotationVisitor1.visit(null, "kotlin.jvm.PlatformType");
annotationVisitor1.visit(
- null, "Lcom/permutive/android/event/api/model/TrackBatchEventResponse;");
+ null, "Lcom/android/tools/r8/shaking/b134858535/TrackBatchEventResponse;");
annotationVisitor1.visit(null, "<name for destructuring parameter 0>");
annotationVisitor1.visit(null, "");
- annotationVisitor1.visit(null, "Lcom/permutive/android/config/api/model/SdkConfiguration;");
+ annotationVisitor1.visit(
+ null, "Lcom/android/tools/r8/shaking/b134858535/SdkConfiguration;");
annotationVisitor1.visit(null, "apply");
annotationVisitor1.visitEnd();
}
annotationVisitor0.visitEnd();
}
classWriter.visitInnerClass(
- "com/permutive/android/event/EventPublisher$b", null, null, ACC_FINAL | ACC_STATIC);
+ "com/android/tools/r8/shaking/b134858535/EventPublisher$b",
+ null,
+ null,
+ ACC_FINAL | ACC_STATIC);
{
fieldVisitor =
classWriter.visitField(
ACC_FINAL | ACC_SYNTHETIC,
"a",
- "Lcom/permutive/android/event/EventPublisher;",
+ "Lcom/android/tools/r8/shaking/b134858535/EventPublisher;",
null,
null);
fieldVisitor.visitEnd();
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
index 8bde97b..6f9c298 100644
--- a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
@@ -4,32 +4,62 @@
package com.android.tools.r8.shaking.b134858535;
+import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
import com.android.tools.r8.TestBase;
-import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import java.util.List;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+@RunWith(Parameterized.class)
public class EventPublisherTest extends TestBase {
+ private final KotlinCompiler kotlinc;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getKotlinCompilers(),
+ TestBase.getTestParameters().withDexRuntimes().withAllApiLevels().build());
+ }
+
+ public EventPublisherTest(KotlinCompiler kotlinc, TestParameters parameters) {
+ this.kotlinc = kotlinc;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testPrivateMethodsInLambdaClass() throws CompilationFailedException {
+ // This test only tests if the dump can be compiled without errors.
+ testForR8(parameters.getBackend())
+ .addProgramClasses(
+ Main.class,
+ Interface.class,
+ EventEntity.class,
+ Flowable.class,
+ SdkConfiguration.class,
+ TrackBatchEventResponse.class)
+ .addProgramClassFileData(EventPublisher$bDump.dump())
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addKeepClassRules(Interface.class)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .addHorizontallyMergedLambdaClassesInspector(
+ inspector -> inspector.assertClassNotMerged(EventPublisher$b.class))
+ .compile();
+ }
+
public static class Main {
public static void main(String[] args) {
new EventPublisher$b().apply("foo");
}
}
-
- @Test
- public void testPrivateMethodsInLambdaClass() throws CompilationFailedException {
- // This test only tests if the dump can be compiled without errors.
- testForR8(Backend.DEX)
- .addProgramClasses(Main.class, Interface.class)
- .addProgramClassFileData(EventPublisher$bDump.dump())
- .addKeepClassRules(Interface.class)
- .addKeepMainRule(Main.class)
- .setMinApi(AndroidApiLevel.L)
- .addHorizontallyMergedLambdaClassesInspector(
- inspector -> inspector.assertClassNotMerged(EventPublisher$b.class))
- .compile();
- }
}
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/Flowable.java b/src/test/java/com/android/tools/r8/shaking/b134858535/Flowable.java
new file mode 100644
index 0000000..928744f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/Flowable.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.b134858535;
+
+public class Flowable {}
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/SdkConfiguration.java b/src/test/java/com/android/tools/r8/shaking/b134858535/SdkConfiguration.java
new file mode 100644
index 0000000..39f22e3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/SdkConfiguration.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.b134858535;
+
+public class SdkConfiguration {}
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/TrackBatchEventResponse.java b/src/test/java/com/android/tools/r8/shaking/b134858535/TrackBatchEventResponse.java
new file mode 100644
index 0000000..ae8dfb6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/TrackBatchEventResponse.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.b134858535;
+
+public class TrackBatchEventResponse {}
diff --git a/src/test/java/com/android/tools/r8/shaking/clinit/ClassNotInitializedByCheckCastTest.java b/src/test/java/com/android/tools/r8/shaking/clinit/ClassNotInitializedByCheckCastTest.java
index 5a3efa6..484526f 100644
--- a/src/test/java/com/android/tools/r8/shaking/clinit/ClassNotInitializedByCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/clinit/ClassNotInitializedByCheckCastTest.java
@@ -5,13 +5,11 @@
package com.android.tools.r8.shaking.clinit;
import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -45,15 +43,8 @@
}
private void inspect(CodeInspector inspector) {
- if (parameters.isCfRuntime()) {
- // Check that A.<clinit>() is removed.
- ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject.clinit(), isAbsent());
- } else {
- // Check that A is removed.
- assertThat(inspector.clazz(A.class), isAbsent());
- }
+ // Check that A is removed.
+ assertThat(inspector.clazz(A.class), isAbsent());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
index 32a861a..0a54cf8 100644
--- a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
@@ -44,7 +44,10 @@
throws Exception {
testForR8(parameters.getBackend())
.addProgramClasses(
- InterfaceWithDefaultMethods.class, ClassImplementingInterface.class, TestClass.class)
+ InterfaceWithDefaultMethods.class,
+ ClassImplementingInterface.class,
+ OtherClassImplementingInterface.class,
+ TestClass.class)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(TestClass.class)
.addKeepRules(additionalKeepRules)
diff --git a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking12Test.java b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking12Test.java
index b30a14d..15e18bd 100644
--- a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking12Test.java
+++ b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking12Test.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.shaking.TreeShakingTest;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
@@ -25,7 +26,13 @@
@Parameters(name = "mode:{0}-{1} minify:{2}")
public static List<Object[]> data() {
- return defaultTreeShakingParameters();
+ return buildParameters(
+ Frontend.values(),
+ getTestParameters()
+ .withAllRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.K)
+ .build(),
+ MinifyMode.values());
}
public TreeShaking12Test(Frontend frontend, TestParameters parameters, MinifyMode minify) {
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
index 04e2c9f..4e53505 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
@@ -14,9 +14,11 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8CompatTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
@@ -68,12 +70,21 @@
}
private void test(Class<?> mainClass, Class<?> mentionedClass) throws Exception {
+ test(mainClass, mentionedClass, null);
+ }
+
+ private void test(
+ Class<?> mainClass,
+ Class<?> mentionedClass,
+ ThrowableConsumer<R8CompatTestBuilder> configuration)
+ throws Exception {
CodeInspector inspector =
testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
.noMinification()
.allowAccessModification()
.addProgramClasses(mainClass, mentionedClass)
.addKeepMainRule(mainClass)
+ .apply(configuration)
.setMinApi(parameters.getApiLevel())
.compile()
.inspector();
@@ -86,7 +97,12 @@
@Test
public void testKeepDefaultInitializer() throws Exception {
- test(TestMain.class, TestMain.MentionedClass.class);
+ test(
+ TestMain.class,
+ TestMain.MentionedClass.class,
+ testBuilder ->
+ testBuilder.addProgramClasses(
+ TestMain.MentionedClassWithAnnotation.class, TestAnnotation.class));
}
@Test
@@ -215,7 +231,7 @@
testCheckCast(
TestMainWithCheckCast.class,
TestClassWithDefaultConstructor.class,
- forceProguardCompatibility || parameters.isCfRuntime());
+ forceProguardCompatibility);
testCheckCast(TestMainWithoutCheckCast.class, TestClassWithDefaultConstructor.class, false);
}
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/keepinterface/CompatKeepInterfaceAsInstantiatedTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/keepinterface/CompatKeepInterfaceAsInstantiatedTest.java
index 7f4606c..38a6b4f 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/keepinterface/CompatKeepInterfaceAsInstantiatedTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/keepinterface/CompatKeepInterfaceAsInstantiatedTest.java
@@ -127,7 +127,9 @@
throws Exception {
return builder
// Add -dontwarn to avoid PG failing since this test runner class is not present.
- .addKeepRules("-dontwarn " + CompatKeepInterfaceAsInstantiatedTest.class.getTypeName())
+ .applyIf(
+ builder.isProguardTestBuilder(),
+ b -> b.addDontWarn(CompatKeepInterfaceAsInstantiatedTest.class))
.noMinification()
.addProgramClasses(main, Foo.class)
.addKeepMainRule(main)
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithFieldValuePropagationTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithFieldValuePropagationTest.java
index 908297c..cc1a987 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithFieldValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithFieldValuePropagationTest.java
@@ -23,7 +23,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public IfWithFieldValuePropagationTest(TestParameters parameters) {
@@ -48,8 +48,9 @@
.addRunClasspathFiles(
testForR8(parameters.getBackend())
.addProgramClasses(Library.class)
+ .addClasspathClasses(Layout.class)
.addKeepAllClassesRule()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.writeToZip())
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithMethodValuePropagationTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithMethodValuePropagationTest.java
index f795067..e377809 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithMethodValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/membervaluepropagation/IfWithMethodValuePropagationTest.java
@@ -48,6 +48,7 @@
.addRunClasspathFiles(
testForR8(parameters.getBackend())
.addProgramClasses(Library.class)
+ .addClasspathClasses(Layout.class)
.addKeepAllClassesRule()
.setMinApi(parameters.getRuntime())
.compile()
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
index 7ea419c..6b01b51 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
@@ -11,6 +11,7 @@
import static org.junit.Assert.assertNotEquals;
import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -78,6 +79,11 @@
}
@Override
+ public void configure(R8FullTestBuilder builder) {
+ builder.enableNeverClassInliningAnnotations();
+ }
+
+ @Override
public Class<?> getTestClass() {
return TestClass.class;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java b/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java
index 1d559b7..fae800c 100644
--- a/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java
@@ -43,6 +43,7 @@
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
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 888b231..4740853 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
@@ -173,6 +173,9 @@
.addInnerClasses(KeepParameterNamesTest.class)
.addKeepMainRule(TestClass.class)
.addKeepRules("-keep class " + Api.class.getTypeName() + "{ api*(...); }")
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .enableUnusedArgumentAnnotations()
.minification(enableMinification)
.apply(this::configureKeepParameterNames)
.compile()
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedClassTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedClassTestRunner.java
index 47659e2..3f3c43e 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedClassTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedClassTestRunner.java
@@ -46,7 +46,9 @@
.enableGraphInspector()
.enableInliningAnnotations()
.addProgramClasses(CLASS)
+ .addKeepAnnotation()
.addKeepRules("-keep @com.android.tools.r8.Keep class * { public *; }")
+ .addInliningAnnotations()
.run(CLASS)
.assertSuccessWithOutput(EXPECTED)
.graphInspector();
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedMethodTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedMethodTestRunner.java
index 2f3fea1..a5fb706 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByAnnotatedMethodTestRunner.java
@@ -62,6 +62,7 @@
.enableGraphInspector()
.enableInliningAnnotations()
.addProgramClasses(CLASSES)
+ .addKeepAnnotation()
.addKeepMainRule(CLASS)
.addKeepRules(keepAnnotatedMethodsRule, keepClassesOfAnnotatedMethodsRule)
.run(CLASS)
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalRuleTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalRuleTestRunner.java
index c813307..32c8662 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalRuleTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalRuleTestRunner.java
@@ -108,7 +108,7 @@
// Check baz is kept by the if rule.
QueryNode barMethodNode = inspector.method(bazMethod).assertNotRenamed();
- ifRuleInstances.assertAllMatch(n -> barMethodNode.isKeptBy(n));
+ ifRuleInstances.assertAllMatch(barMethodNode::isKeptBy);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
whyAreYouKeepingConsumer.printWhyAreYouKeeping(bazMethod, new PrintStream(baos));
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByFieldReflectionTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByFieldReflectionTestRunner.java
index a43e42c..02d8481 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByFieldReflectionTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByFieldReflectionTestRunner.java
@@ -30,16 +30,17 @@
private static final Class<?> CLASS = KeptByFieldReflectionTest.class;
private static final Collection<Class<?>> CLASSES = Arrays.asList(CLASS);
+ private static final String TYPE_NAME = CLASS.getTypeName();
private final String EXPECTED_STDOUT = StringUtils.lines("got foo: 42");
private final String EXPECTED_WHYAREYOUKEEPING =
StringUtils.lines(
- "int com.android.tools.r8.shaking.keptgraph.KeptByFieldReflectionTest.foo",
+ "int " + TYPE_NAME + ".foo",
"|- is reflected from:",
- "| void com.android.tools.r8.shaking.keptgraph.KeptByFieldReflectionTest.main(java.lang.String[])",
+ "| void " + TYPE_NAME + ".main(java.lang.String[])",
"|- is referenced in keep rule:",
- "| -keep class com.android.tools.r8.shaking.keptgraph.KeptByFieldReflectionTest { public static void main(java.lang.String[]); }");
+ "| -keep class " + TYPE_NAME + " { public static void main(java.lang.String[]); }");
private final Backend backend;
@@ -67,6 +68,7 @@
testForR8(backend)
.enableGraphInspector(consumer)
.addProgramClasses(CLASSES)
+ .addKeepAnnotation()
.addKeepMainRule(CLASS)
.run(CLASS)
.assertSuccessWithOutput(EXPECTED_STDOUT)
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByMethodReflectionTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByMethodReflectionTestRunner.java
index c8afcdc..be0fcff 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByMethodReflectionTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByMethodReflectionTestRunner.java
@@ -28,16 +28,17 @@
private static final Class<?> CLASS = KeptByMethodReflectionTest.class;
private static final Collection<Class<?>> CLASSES = Arrays.asList(CLASS);
+ private static final String TYPE_NAME = CLASS.getTypeName();
private final String EXPECTED_STDOUT = StringUtils.lines("called foo");
private final String EXPECTED_WHYAREYOUKEEPING =
StringUtils.lines(
- "void com.android.tools.r8.shaking.keptgraph.KeptByMethodReflectionTest.foo()",
+ "void " + TYPE_NAME + ".foo()",
"|- is reflected from:",
- "| void com.android.tools.r8.shaking.keptgraph.KeptByMethodReflectionTest.main(java.lang.String[])",
+ "| void " + TYPE_NAME + ".main(java.lang.String[])",
"|- is referenced in keep rule:",
- "| -keep class com.android.tools.r8.shaking.keptgraph.KeptByMethodReflectionTest { public static void main(java.lang.String[]); }");
+ "| -keep class " + TYPE_NAME + " { public static void main(java.lang.String[]); }");
private final Backend backend;
@@ -64,6 +65,7 @@
testForR8(backend)
.enableGraphInspector(consumer)
.addProgramClasses(CLASSES)
+ .addKeepAnnotation()
.addKeepMainRule(CLASS)
.run(CLASS)
.assertSuccessWithOutput(EXPECTED_STDOUT)
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoRulesTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoRulesTestRunner.java
index 5623924..042679f 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoRulesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoRulesTestRunner.java
@@ -54,6 +54,7 @@
testForR8(backend)
.enableGraphInspector()
.addProgramClasses(CLASSES)
+ .addKeepAnnotation()
.addKeepRules(keepPublicRule, keepFooRule)
.run(CLASS)
.assertSuccessWithOutput(EXPECTED)
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
index 4d385a0..230c0cf 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptViaClassInitializerTestRunner.java
@@ -21,6 +21,7 @@
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.graphinspector.GraphInspector;
@@ -28,6 +29,7 @@
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.function.Supplier;
+import org.hamcrest.Matcher;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -110,6 +112,7 @@
.addProgramClassesAndInnerClasses(Main.class, A.class, T.class)
.addKeepMethodRules(mainMethod)
.enableMemberValuePropagationAnnotations()
+ .enableNeverClassInliningAnnotations()
.setMinApi(AndroidApiLevel.N)
.apply(
b -> {
@@ -129,12 +132,13 @@
consumer.printWhyAreYouKeeping(classFromClass(A.class), new PrintStream(baos));
assertThat(baos.toString(), containsString(KEPT_REASON_SUFFIX));
- // TODO(b/124499108): Currently synthetic lambda classes are referenced,
+ // TODO(b/124499108): Currently (internal) synthetic lambda classes are referenced,
// should be their originating context.
+ Matcher<String> hasLambda = SyntheticItemsTestUtils.containsInternalSyntheticReference();
if (parameters.isDexRuntime()) {
- assertThat(baos.toString(), containsString("-$$Lambda$"));
+ assertThat(baos.toString(), hasLambda);
} else {
- assertThat(baos.toString(), not(containsString("-$$Lambda$")));
+ assertThat(baos.toString(), not(hasLambda));
}
}
}
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 cea851e..6f868fc 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
@@ -5,14 +5,12 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -53,13 +51,10 @@
testForR8(parameters.getBackend())
.addProgramFiles(MOCKITO_INTERFACE_JAR)
.addKeepRuleFiles(flagToKeepTestRunner)
- .allowDiagnosticWarningMessages(
- parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+ .addDontWarn("org.junit.**", "org.mockito.**")
.minification(minify)
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- containsString("required for default or static interface methods desugaring"))
.inspector();
ClassSubject itf = inspector.clazz(M_I);
assertThat(itf, isPresent());
@@ -75,13 +70,10 @@
testForR8(parameters.getBackend())
.addProgramFiles(MOCKITO_INTERFACE_JAR)
.addKeepRuleFiles(flagToKeepInterfaceConditionally)
- .allowDiagnosticWarningMessages(
- parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+ .addDontWarn("org.junit.**", "org.mockito.**")
.minification(minify)
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- containsString("required for default or static interface methods desugaring"))
.inspector();
ClassSubject itf = inspector.clazz(M_I);
assertThat(itf, isPresent());
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/C.java b/src/test/java/com/android/tools/r8/shaking/testrules/C.java
index f402864..497c218 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/C.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/C.java
@@ -4,14 +4,12 @@
package com.android.tools.r8.shaking.testrules;
-import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverInline;
public class C {
private static int i;
- @AssumeMayHaveSideEffects
@NeverInline
public static int x() {
return i;
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
index d4e5972..b669c95 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
@@ -42,6 +42,7 @@
return testForR8(parameters.getBackend())
.addProgramClasses(Main.class, A.class, B.class, C.class)
.addKeepRules(proguardConfiguration)
+ .enableInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.enableNoStaticClassMergingAnnotations()
.enableProguardTestOptions()
diff --git a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
index eeb280b..477e1f3 100644
--- a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
@@ -79,6 +79,7 @@
.addKeepRules("-whyareyoukeeping class " + A.class.getTypeName())
// Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
.collectStdout()
+ .addInliningAnnotations()
.compile()
.assertStdoutThatMatches(equalTo(expected));
}
@@ -90,6 +91,7 @@
.addProgramClasses(A.class)
.addKeepMethodRules(Reference.methodFromMethod(A.class.getMethod("foo")))
.setKeptGraphConsumer(graphConsumer)
+ .addInliningAnnotations()
.compile();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -139,13 +141,13 @@
.allowUnusedProguardConfigurationRules()
// Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
.collectStdout()
+ .addInliningAnnotations()
.compile()
.assertNoStdout();
}
@Test
public void testNonExistentMethodWhyAreYouKeepingViaProguardConfig() throws Exception {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
String aName = A.class.getTypeName();
testForR8(backend)
.addProgramClasses(A.class)
@@ -153,6 +155,7 @@
.addKeepRules("-whyareyoukeeping class " + aName + " { nonExistentMethod(); }")
// Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
.collectStdout()
+ .addInliningAnnotations()
.compile()
.assertStdoutThatMatches(not(equalTo("")));
}
diff --git a/src/test/java/com/android/tools/r8/smali/ConstantFoldingTest.java b/src/test/java/com/android/tools/r8/smali/ConstantFoldingTest.java
index fb0785e..e5a8027 100644
--- a/src/test/java/com/android/tools/r8/smali/ConstantFoldingTest.java
+++ b/src/test/java/com/android/tools/r8/smali/ConstantFoldingTest.java
@@ -31,9 +31,8 @@
public class ConstantFoldingTest extends SmaliTestBase {
- @FunctionalInterface
public interface TriConsumer<T, U, V> {
- public void accept(T t, U u, V v);
+ void accept(T t, U u, V v);
}
private class SmaliBuilderWithCheckers {
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
new file mode 100644
index 0000000..438d3f9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
@@ -0,0 +1,77 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.synthesis;
+
+import static org.hamcrest.CoreMatchers.containsString;
+
+import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
+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.synthesis.SyntheticNaming.Phase;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import java.lang.reflect.Method;
+import org.hamcrest.Matcher;
+
+public class SyntheticItemsTestUtils {
+
+ public static ClassReference syntheticCompanionClass(Class<?> clazz) {
+ return Reference.classFromDescriptor(
+ InterfaceMethodRewriter.getCompanionClassDescriptor(
+ Reference.classFromClass(clazz).getDescriptor()));
+ }
+
+ private static ClassReference syntheticClass(Class<?> clazz, SyntheticKind kind, int id) {
+ return SyntheticNaming.makeSyntheticReferenceForTest(
+ Reference.classFromClass(clazz), kind, "" + id);
+ }
+
+ public static MethodReference syntheticBackportMethod(Class<?> clazz, int id, Method method) {
+ ClassReference syntheticHolder =
+ syntheticClass(clazz, SyntheticNaming.SyntheticKind.BACKPORT, id);
+ MethodReference originalMethod = Reference.methodFromMethod(method);
+ return Reference.methodFromDescriptor(
+ syntheticHolder.getDescriptor(),
+ SyntheticNaming.INTERNAL_SYNTHETIC_METHOD_PREFIX,
+ originalMethod.getMethodDescriptor());
+ }
+
+ public static ClassReference syntheticLambdaClass(Class<?> clazz, int id) {
+ return syntheticClass(clazz, SyntheticNaming.SyntheticKind.LAMBDA, id);
+ }
+
+ public static MethodReference syntheticLambdaMethod(Class<?> clazz, int id, Method method) {
+ ClassReference syntheticHolder = syntheticLambdaClass(clazz, id);
+ MethodReference originalMethod = Reference.methodFromMethod(method);
+ return Reference.methodFromDescriptor(
+ syntheticHolder.getDescriptor(),
+ originalMethod.getMethodName(),
+ originalMethod.getMethodDescriptor());
+ }
+
+ public static boolean isInternalLambda(ClassReference reference) {
+ return SyntheticNaming.isSynthetic(reference, Phase.INTERNAL, SyntheticKind.LAMBDA);
+ }
+
+ public static boolean isExternalLambda(ClassReference reference) {
+ return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.LAMBDA);
+ }
+
+ public static boolean isExternalStaticInterfaceCall(ClassReference reference) {
+ return SyntheticNaming.isSynthetic(
+ reference, Phase.EXTERNAL, SyntheticKind.STATIC_INTERFACE_CALL);
+ }
+
+ public static boolean isExternalTwrCloseMethod(ClassReference reference) {
+ return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.TWR_CLOSE_RESOURCE);
+ }
+
+ public static Matcher<String> containsInternalSyntheticReference() {
+ return containsString(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
+ }
+
+ public static Matcher<String> containsExternalSyntheticReference() {
+ return containsString(SyntheticNaming.getPhaseSeparator(Phase.EXTERNAL));
+ }
+}
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 cac07ed..8279af3 100644
--- a/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
+++ b/src/test/java/com/android/tools/r8/utils/StringUtilsTest.java
@@ -33,9 +33,9 @@
private void assertListEquals(List<String> xs, List<String> ys) {
assertEquals(
- StringUtils.join(xs, ", ", BraceType.SQUARE, s -> '"' + StringUtils.toASCIIString(s) + '"'),
- StringUtils.join(ys, ", ", BraceType.SQUARE, s -> '"' + StringUtils.toASCIIString(s) + '"')
- );
+ StringUtils.join(", ", xs, s -> '"' + StringUtils.toASCIIString(s) + '"', BraceType.SQUARE),
+ StringUtils.join(
+ ", ", ys, s -> '"' + StringUtils.toASCIIString(s) + '"', BraceType.SQUARE));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java
deleted file mode 100644
index 9e78bac..0000000
--- a/src/test/java/com/android/tools/r8/utils/SyntheticItemsTestUtils.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.utils;
-
-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.synthesis.SyntheticItems;
-import java.lang.reflect.Method;
-
-public class SyntheticItemsTestUtils {
-
- public static ClassReference syntheticClass(Class<?> clazz, int id) {
- return Reference.classFromTypeName(
- clazz.getTypeName() + SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR + id);
- }
-
- public static MethodReference syntheticMethod(Class<?> clazz, int id, Method method) {
- ClassReference syntheticHolder = syntheticClass(clazz, id);
- MethodReference originalMethod = Reference.methodFromMethod(method);
- return Reference.methodFromDescriptor(
- syntheticHolder.getDescriptor(),
- SyntheticItems.INTERNAL_SYNTHETIC_METHOD_PREFIX + 0,
- originalMethod.getMethodDescriptor());
- }
-}
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 ffe8151..a42fa4b 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
@@ -136,6 +136,11 @@
}
@Override
+ public ClassReference getOriginalReference() {
+ return null;
+ }
+
+ @Override
public ClassReference getFinalReference() {
return null;
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
index 87eb583..e9634a5 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
@@ -13,9 +13,14 @@
public class AssertUtils {
- public static <E extends Throwable> void assertFailsCompilation(ThrowingAction<E> action)
- throws E {
- assertFailsCompilationIf(true, action);
+ public static void assertFailsCompilation(ThrowingAction<CompilationFailedException> action) {
+ try {
+ assertFailsCompilationIf(true, action);
+ return;
+ } catch (CompilationFailedException e) {
+ // Should have been caught
+ }
+ fail("Should have failed with a CompilationFailedException");
}
public static <E extends Throwable> void assertFailsCompilation(
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
index 3a9976f..f927e62 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
@@ -285,6 +285,7 @@
&& ((CfInvoke) instruction).getOpcode() == Opcodes.INVOKESPECIAL;
}
+ @Override
public boolean isInvokeDynamic() {
return instruction instanceof CfInvokeDynamic;
}
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 a2d32eb..20d7466 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
@@ -191,6 +191,8 @@
public abstract String getOriginalBinaryName();
+ public abstract ClassReference getOriginalReference();
+
public abstract ClassReference getFinalReference();
public abstract String getFinalName();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
index 4b9f733..2ae5f05 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
@@ -209,6 +209,11 @@
return false;
}
+ @Override
+ public boolean isInvokeDynamic() {
+ return isInvokeCustom();
+ }
+
public boolean isInvokeCustom() {
return instruction instanceof InvokeCustom || instruction instanceof InvokeCustomRange;
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexTryCatchSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexTryCatchSubject.java
index c1fa59a..fea4fbd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexTryCatchSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexTryCatchSubject.java
@@ -54,7 +54,7 @@
@Override
public Stream<TypeSubject> streamGuards() {
return Arrays.stream(tryHandler.pairs)
- .map(pair -> pair.getType())
+ .map(TypeAddrPair::getType)
.map(type -> new TypeSubject(inspector, type));
}
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 a676666..4220b50 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
@@ -34,6 +34,7 @@
import com.android.tools.r8.retrace.RetraceTypeResult;
import com.android.tools.r8.retrace.RetracedField;
import com.android.tools.r8.retrace.Retracer;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.ZipUtils;
@@ -389,6 +390,11 @@
}
@Override
+ public ClassReference getOriginalReference() {
+ return Reference.classFromDescriptor(getOriginalDescriptor());
+ }
+
+ @Override
public ClassReference getFinalReference() {
return Reference.classFromDescriptor(getFinalDescriptor());
}
@@ -430,7 +436,9 @@
@Override
public boolean isSynthesizedJavaLambdaClass() {
- return dexClass.type.getName().contains("$Lambda$");
+ // TODO(141287349): Make this precise based on the map input.
+ return SyntheticItemsTestUtils.isExternalLambda(getOriginalReference())
+ || SyntheticItemsTestUtils.isExternalLambda(getFinalReference());
}
@Override
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index 56436e9..8b34260 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -43,6 +43,8 @@
boolean isInvokeSpecial();
+ boolean isInvokeDynamic();
+
DexMethod getMethod();
boolean isNop();
diff --git a/tools/apk_utils.py b/tools/apk_utils.py
old mode 100644
new mode 100755
index 9155657..c3c616b
--- a/tools/apk_utils.py
+++ b/tools/apk_utils.py
@@ -1,12 +1,40 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
# Copyright (c) 2018, 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.
+import optparse
import os
import subprocess
+import sys
import utils
+USAGE = 'usage: %prog [options] <apk>'
+
+def parse_options():
+ parser = optparse.OptionParser(usage=USAGE)
+ parser.add_option('--keystore',
+ help='keystore file (default ~/.android/app.keystore)',
+ default='~/.android/app.keystore')
+ parser.add_option('--sign',
+ help='Sign the passed in apk.',
+ default=False,
+ action='store_true')
+ parser.add_option('--use_apksigner',
+ help='Use apksigner to sign.',
+ default=False,
+ action='store_true')
+ parser.add_option('--output',
+ help='Where to put the signed apk.)',
+ default=None)
+
+ (options, args) = parser.parse_args()
+ if len(args) != 1:
+ parser.error('Expected <apk> argument, got: ' + ' '.join(args))
+ apk = args[0]
+ return (options, apk)
+
+
def sign(unsigned_apk, signed_apk, keystore, quiet=False, logging=True):
utils.Print('Signing (ignore the warnings)', quiet=quiet)
cmd = ['zip', '-d', unsigned_apk, 'META-INF/*']
@@ -37,3 +65,22 @@
unsigned_apk
]
utils.RunCmd(cmd, quiet=quiet, logging=logging)
+
+
+def main():
+ (options, apk) = parse_options()
+ if options.sign:
+ if not options.output:
+ print('When signing you must specify an output apk')
+ return 1
+ if not options.keystore:
+ print('When signing you must specify a keystore')
+ return 1
+ if options.use_apksigner:
+ sign_with_apksigner(apk, options.output, options.keystore)
+ else:
+ sign(apk, options.output, options.keystore)
+ return 0
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 31bb4c6..179a50f 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
# Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
@@ -41,7 +41,7 @@
def prepare_release(args):
if args.version:
- print "Cannot manually specify version when making a dev release."
+ print("Cannot manually specify version when making a dev release.")
sys.exit(1)
def make_release(args):
@@ -57,13 +57,13 @@
if result:
break
if not result or not result.group(1):
- print 'Failed to find version label matching %s(\d+)-dev'\
- % R8_DEV_BRANCH
+ print('Failed to find version label matching %s(\d+)-dev'\
+ % R8_DEV_BRANCH)
sys.exit(1)
try:
patch_version = int(result.group(1))
except ValueError:
- print 'Failed to convert version to integer: %s' % result.group(1)
+ print('Failed to convert version to integer: %s' % result.group(1))
old_version = '%s.%s-dev' % (R8_DEV_BRANCH, patch_version)
version = '%s.%s-dev' % (R8_DEV_BRANCH, patch_version + 1)
@@ -74,8 +74,8 @@
other_diff = version_change_diff(
merge_diff_output, old_version, "master")
if not other_diff:
- print 'Merge point from master (%s)' % commithash, \
- 'is the same as exiting release (%s).' % old_version
+ print('Merge point from master (%s)' % commithash, \
+ 'is the same as exiting release (%s).' % old_version)
sys.exit(1)
if args.dev_pre_cherry_pick:
@@ -102,7 +102,7 @@
if not args.dry_run:
input = raw_input('Publish dev release version %s [y/N]:' % version)
if input != 'y':
- print 'Aborting dev release for %s' % version
+ print('Aborting dev release for %s' % version)
sys.exit(1)
maybe_check_call(args, [
@@ -139,25 +139,25 @@
def validate_version_change_diff(version_diff_output, old_version, new_version):
invalid = version_change_diff(version_diff_output, old_version, new_version)
if invalid:
- print "Unexpected diff:"
- print "=" * 80
- print version_diff_output
- print "=" * 80
+ print("Unexpected diff:")
+ print("=" * 80)
+ print(version_diff_output)
+ print("=" * 80)
accept_string = 'THE DIFF IS OK!'
input = raw_input(
"Accept the additonal diff as part of the release? "
"Type '%s' to accept: " % accept_string)
if input != accept_string:
- print "You did not type '%s'" % accept_string
- print 'Aborting dev release for %s' % version
+ print("You did not type '%s'" % accept_string)
+ print('Aborting dev release for %s' % version)
sys.exit(1)
def maybe_check_call(args, cmd):
if args.dry_run:
- print 'DryRun:', ' '.join(cmd)
+ print('DryRun:', ' '.join(cmd))
else:
- print ' '.join(cmd)
+ print(' '.join(cmd))
return subprocess.check_call(cmd)
@@ -185,7 +185,7 @@
if not options.use_existing_work_branch:
subprocess.check_call(['git', 'commit', '-a', '-m', git_message])
else:
- print ('Not committing when --use-existing-work-branch. '
+ print('Not committing when --use-existing-work-branch. '
+ 'Commit message should be:\n\n'
+ git_message
+ '\n')
@@ -194,7 +194,7 @@
if not options.no_upload and not options.use_existing_work_branch:
process = subprocess.Popen(['repo', 'upload', '.', '--verify'],
stdin=subprocess.PIPE)
- return process.communicate(input='y\n')[0]
+ return process.communicate(input=b'y\n')[0]
def prepare_aosp(args):
@@ -202,7 +202,7 @@
assert os.path.exists(args.aosp), "Could not find AOSP path %s" % args.aosp
def release_aosp(options):
- print "Releasing for AOSP"
+ print("Releasing for AOSP")
if options.dry_run:
return 'DryRun: omitting AOSP release for %s' % options.version
@@ -228,7 +228,7 @@
gfile = '/bigstore/r8-releases/raw/%s/r8lib.zip' % args.version
release_id = gmaven_publisher_stage(options, [gfile])
- print "Staged Release ID " + release_id + ".\n"
+ print("Staged Release ID " + release_id + ".\n")
gmaven_publisher_stage_redir_test_info(
release_id, "com.android.tools:r8:%s" % args.version, "r8lib.jar")
@@ -236,13 +236,13 @@
input = raw_input("Continue with publishing [y/N]:")
if input != 'y':
- print 'Aborting release to Google maven'
+ print('Aborting release to Google maven')
sys.exit(1)
gmaven_publisher_publish(args, release_id)
- print
- print "Published. Use the email workflow for approval."
+ print("")
+ print("Published. Use the email workflow for approval.")
return release_maven
@@ -275,7 +275,7 @@
% args.studio)
def release_studio(options):
- print "Releasing for STUDIO"
+ print("Releasing for STUDIO")
if options.dry_run:
return 'DryRun: omitting studio release for %s' % options.version
@@ -329,7 +329,7 @@
def download_gfile(gfile, dst):
if not gfile.startswith('/bigstore/r8-releases'):
- print 'Unexpected gfile prefix for %s' % gfile
+ print('Unexpected gfile prefix for %s' % gfile)
sys.exit(1)
urllib.urlretrieve(
@@ -348,7 +348,7 @@
check_no_google3_client(args, args.p4_client)
def release_google3(options):
- print "Releasing for Google 3"
+ print("Releasing for Google 3")
if options.dry_run:
return 'DryRun: omitting g3 release for %s' % options.version
@@ -362,7 +362,7 @@
g4_open('src.jar')
g4_open('lib.jar')
g4_open('lib.jar.map')
- g4_open('retrace.jar')
+ g4_open('retrace_lib.jar')
g4_open('desugar_jdk_libs_configuration.jar')
download_file(options.version, 'r8-full-exclude-deps.jar', 'full.jar')
download_file(options.version, 'r8-src.jar', 'src.jar')
@@ -371,7 +371,7 @@
options.version, 'r8lib-exclude-deps.jar.map', 'lib.jar.map')
download_file(options.version, 'desugar_jdk_libs_configuration.jar',
'desugar_jdk_libs_configuration.jar')
- download_file(options.version, 'r8retrace-exclude-deps.jar', 'retrace.jar')
+ download_file(options.version, 'r8retrace-exclude-deps.jar', 'retrace_lib.jar')
g4_open('METADATA')
sed(r'[1-9]\.[0-9]{1,2}\.[0-9]{1,3}-dev',
options.version,
@@ -456,7 +456,7 @@
if not args.use_existing_work_branch:
subprocess.check_call(['git', 'commit', '-a', '-m', git_message])
else:
- print ('Not committing when --use-existing-work-branch. '
+ print('Not committing when --use-existing-work-branch. '
+ 'Commit message should be:\n\n'
+ git_message
+ '\n')
@@ -497,23 +497,23 @@
release_id = gmaven_publisher_stage(
args, [library_gfile, configuration_gfile])
- print "Staged Release ID " + release_id + ".\n"
+ print("Staged Release ID " + release_id + ".\n")
gmaven_publisher_stage_redir_test_info(
release_id,
"com.android.tools:%s:%s" % (DESUGAR_JDK_LIBS, library_version),
library_jar)
- print
+ print("")
input = raw_input("Continue with publishing [y/N]:")
if input != 'y':
- print 'Aborting release to Google maven'
+ print('Aborting release to Google maven')
sys.exit(1)
gmaven_publisher_publish(args, release_id)
- print
- print "Published. Use the email workflow for approval."
+ print("")
+ print("Published. Use the email workflow for approval.")
return make_release
@@ -524,7 +524,7 @@
dirs = os.listdir(
os.path.join('com', 'android', 'tools', DESUGAR_JDK_LIBS_CONFIGURATION))
if len(dirs) != 1:
- print 'Unexpected archive content, %s' + dirs
+ print('Unexpected archive content, %s' + dirs)
sys.exit(1)
version = dirs[0]
@@ -537,14 +537,14 @@
'%s-%s.pom' % (DESUGAR_JDK_LIBS_CONFIGURATION, version))
version_from_pom = extract_version_from_pom(pom_file)
if version != version_from_pom:
- print 'Version mismatch, %s != %s' % (version, version_from_pom)
+ print('Version mismatch, %s != %s' % (version, version_from_pom))
sys.exit(1)
def check_no_google3_client(args, client_name):
if not args.use_existing_work_branch:
clients = subprocess.check_output('g4 myclients', shell=True)
if ':%s:' % client_name in clients:
- print ("Remove the existing '%s' client before continuing " +
+ print("Remove the existing '%s' client before continuing " +
"(force delete: 'g4 citc -d -f %s'), " +
"or use option --use-existing-work-branch.") % (client_name, client_name)
sys.exit(1)
@@ -563,11 +563,11 @@
def gmaven_publisher_stage(args, gfiles):
if args.dry_run:
- print 'Dry-run, would have staged %s' % gfiles
+ print('Dry-run, would have staged %s' % gfiles)
return 'dry-run-release-id'
- print "Staging: %s" % ', '.join(gfiles)
- print
+ print("Staging: %s" % ', '.join(gfiles))
+ print("")
cmd = [GMAVEN_PUBLISHER, 'stage', '--gfile', ','.join(gfiles)]
output = subprocess.check_output(cmd)
@@ -579,13 +579,13 @@
matches = GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN.findall(output)
if matches == None or len(matches) > 1:
- print ("Could not determine the release ID from the gmaven_publisher " +
- "output. Expected a line with 'Release ID = <release id>'.")
- print "Output was:"
- print output
+ print("Could not determine the release ID from the gmaven_publisher " +
+ "output. Expected a line with 'Release ID = <release id>'.")
+ print("Output was:")
+ print(output)
sys.exit(1)
- print output
+ print(output)
release_id = matches[0]
return release_id
@@ -604,7 +604,7 @@
+ "-Dartifact=%s "
+ "-Ddest=%s") % (artifact, dst)
- print """To test the staged content with 'redir' run:
+ print("""To test the staged content with 'redir' run:
%s
@@ -620,12 +620,12 @@
rm -rf /tmp/maven_repo_local
%s
-""" % (redir_command, get_command)
+""" % (redir_command, get_command))
def gmaven_publisher_publish(args, release_id):
if args.dry_run:
- print 'Dry-run, would have published %s' % release_id
+ print('Dry-run, would have published %s' % release_id)
return
cmd = [GMAVEN_PUBLISHER, 'publish', release_id]
@@ -636,11 +636,11 @@
for line in diff.splitlines():
if line.startswith('-R8') and \
line != "-R8_DEV_BRANCH = '%s'" % old_version:
- print line
+ print(line)
invalid_line = line
elif line.startswith('+R8') and \
line != "+R8_DEV_BRANCH = '%s'" % new_version:
- print line
+ print(line)
invalid_line = line
return invalid_line
@@ -648,15 +648,15 @@
def validate_branch_change_diff(version_diff_output, old_version, new_version):
invalid = branch_change_diff(version_diff_output, old_version, new_version)
if invalid:
- print
- print "The diff for the branch change in tools/release.py is not as expected:"
- print
- print "=" * 80
- print version_diff_output
- print "=" * 80
- print
- print "Validate the uploaded CL before landing."
- print
+ print("")
+ print("The diff for the branch change in tools/release.py is not as expected:")
+ print("")
+ print("=" * 80)
+ print(version_diff_output)
+ print("=" * 80)
+ print("")
+ print("Validate the uploaded CL before landing.")
+ print("")
def prepare_branch(args):
@@ -668,7 +668,7 @@
semver = utils.check_basic_semver_version(
branch_version, ", release branch version should be x.y", 2)
if not semver.larger_than(current_semver):
- print ('New branch version "'
+ print('New branch version "'
+ branch_version
+ '" must be strictly larger than the current "'
+ R8_DEV_BRANCH
@@ -703,14 +703,14 @@
if not options.dry_run:
input = raw_input('Create new branch for %s [y/N]:' % branch_version)
if input != 'y':
- print 'Aborting new branch for %s' % branch_version
+ print('Aborting new branch for %s' % branch_version)
sys.exit(1)
maybe_check_call(options, [
'git', 'push', 'origin', 'HEAD:%s' % branch_version])
maybe_tag(options, full_version)
- print ('Updating tools/r8_release.py to make new dev releases on %s'
+ print('Updating tools/r8_release.py to make new dev releases on %s'
% branch_version)
subprocess.check_call(['git', 'new-branch', 'update-release-script'])
@@ -723,7 +723,7 @@
if result:
break
if not result or not result.group(1):
- print 'Failed to find version label in %s' % THIS_FILE_RELATIVE
+ print('Failed to find version label in %s' % THIS_FILE_RELATIVE)
sys.exit(1)
# Update this file with the new dev branch.
@@ -742,9 +742,9 @@
maybe_check_call(options, ['git', 'cl', 'upload', '-f', '-m', message])
- print
- print 'Make sure to send out the branch change CL for review.'
- print
+ print('')
+ print('Make sure to send out the branch change CL for review.')
+ print('')
return make_branch
@@ -826,12 +826,12 @@
and args.version
and not 'dev' in args.version
and args.bug == []):
- print ("When releasing a release version to Android Studio add the "
+ print("When releasing a release version to Android Studio add the "
+ "list of bugs by using '--bug'")
sys.exit(1)
if args.version and not 'dev' in args.version and args.google3:
- print "You should not roll a release version into google 3"
+ print("You should not roll a release version into google 3")
sys.exit(1)
return args
@@ -843,13 +843,13 @@
if args.new_dev_branch:
if args.google3 or args.studio or args.aosp:
- print 'Cannot create a branch and roll at the same time.'
+ print('Cannot create a branch and roll at the same time.')
sys.exit(1)
targets_to_run.append(prepare_branch(args))
if args.dev_release:
if args.google3 or args.studio or args.aosp:
- print 'Cannot create a dev release and roll at the same time.'
+ print('Cannot create a dev release and roll at the same time.')
sys.exit(1)
targets_to_run.append(prepare_release(args))
@@ -873,10 +873,10 @@
if args.update_desugar_library_in_studio:
if not args.studio:
- print ("--studio required")
+ print("--studio required")
sys.exit(1)
if args.bug == []:
- print ("Update studio mirror of com.android.tools:desugar_jdk_libs "
+ print("Update studio mirror of com.android.tools:desugar_jdk_libs "
+ "requires at least one bug by using '--bug'")
sys.exit(1)
targets_to_run.append(update_desugar_library_in_studio(args))
@@ -885,13 +885,13 @@
for target_closure in targets_to_run:
final_results.append(target_closure(args))
- print '\n\n**************************************************************'
- print 'PRINTING SUMMARY'
- print '**************************************************************\n\n'
+ print('\n\n**************************************************************')
+ print('PRINTING SUMMARY')
+ print('**************************************************************\n\n')
for result in final_results:
if result is not None:
- print result
+ print(result)
if __name__ == '__main__':
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
index 983ce6d..94eae01 100755
--- a/tools/run_on_app.py
+++ b/tools/run_on_app.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
# Copyright (c) 2017, 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.
@@ -215,8 +215,7 @@
# Please add bug number for disabled permutations and please explicitly
# do Bug: #BUG in the commit message of disabling to ensure re-enabling
DISABLED_PERMUTATIONS = [
- # (app, version, type), e.g., ('gmail', '180826.15', 'deploy'),
- ('youtube', '15.09', 'deploy'), # b/150267318
+ # (app, version, type), e.g., ('gmail', '180826.15', 'deploy')
]
def get_permutations():
@@ -232,7 +231,7 @@
}
# Check to ensure that we add all variants here.
assert len(APPS) == len(data_providers)
- for app, data in data_providers.iteritems():
+ for app, data in data_providers.items():
for version in data.VERSIONS:
for type in data.VERSIONS[version]:
if (app, version, type) not in DISABLED_PERMUTATIONS:
@@ -276,9 +275,9 @@
else:
working = 1024 * 8
exit_code = 0
- range = options.find_min_xmx_range_size
+ range = int(options.find_min_xmx_range_size)
while working - not_working > range:
- next_candidate = working - ((working - not_working)/2)
+ next_candidate = int(working - ((working - not_working)/2))
print('working: %s, non_working: %s, next_candidate: %s' %
(working, not_working, next_candidate))
extra_args = ['-Xmx%sM' % next_candidate]
diff --git a/tools/toolhelper.py b/tools/toolhelper.py
index 45d84e2..1cfd0f0 100644
--- a/tools/toolhelper.py
+++ b/tools/toolhelper.py
@@ -27,6 +27,10 @@
cmd.append(jdk.GetJavaExecutable())
if extra_args:
cmd.extend(extra_args)
+ agent, args = extract_debug_agent_from_args(args)
+ if agent:
+ cmd.append(
+ '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005')
if debug:
cmd.append('-ea')
if profile:
@@ -103,3 +107,13 @@
else:
args.append(arg)
return lib, args
+
+def extract_debug_agent_from_args(input_args):
+ agent = False
+ args = []
+ for arg in input_args:
+ if arg in ('--debug-agent', '--debug_agent'):
+ agent = True
+ else:
+ args.append(arg)
+ return agent, args
diff --git a/tools/update_prebuilds_in_android.py b/tools/update_prebuilds_in_android.py
index fe8a3c0..3f30964 100755
--- a/tools/update_prebuilds_in_android.py
+++ b/tools/update_prebuilds_in_android.py
@@ -63,8 +63,8 @@
', as' + dest + ' does not exist already')
def copy_jar_targets(root, target_root, jar_targets, maps):
- srcs = map((lambda t: t[0] + '.jar'), jar_targets)
- dests = map((lambda t: t[1] + '.jar'), jar_targets)
+ srcs = list(map((lambda t: t[0] + '.jar'), jar_targets))
+ dests = list(map((lambda t: t[1] + '.jar'), jar_targets))
copy_targets(root, target_root, srcs, dests, maps=maps)
def copy_other_targets(root, target_root):
@@ -88,7 +88,7 @@
def main_download(hash, maps, targets, target_root, version):
jar_targets = JAR_TARGETS_MAP[targets]
- final_targets = map((lambda t: t[0] + '.jar'), jar_targets) + OTHER_TARGETS
+ final_targets = list(map((lambda t: t[0] + '.jar'), jar_targets)) + OTHER_TARGETS
with utils.TempDir() as root:
for target in final_targets:
if hash:
diff --git a/tools/utils.py b/tools/utils.py
index ee49000..a55ea58 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -169,13 +169,12 @@
logger = ProgressLogger(quiet=quiet) if logging else None
failed = False
while True:
- line = process.stdout.readline()
- if line != b'':
+ line = process.stdout.readline().decode('utf-8')
+ if line != '':
stripped = line.rstrip()
stdout.append(stripped)
if logger:
logger.log(stripped)
-
# TODO(christofferqa): r8 should fail with non-zero exit code.
if ('AssertionError:' in stripped
or 'CompilationError:' in stripped
@@ -269,7 +268,7 @@
cmd = ['git', 'rev-parse', 'HEAD']
PrintCmd(cmd)
with ChangedWorkingDirectory(checkout):
- return subprocess.check_output(cmd).strip()
+ return subprocess.check_output(cmd).decode('utf-8').strip()
def makedirs_if_needed(path):
try:
@@ -512,7 +511,7 @@
def check_java_version():
cmd= [jdk.GetJavaExecutable(), '-version']
output = subprocess.check_output(cmd, stderr = subprocess.STDOUT)
- m = re.search('openjdk version "([^"]*)"', output)
+ m = re.search('openjdk version "([^"]*)"', output.decode('utf-8'))
if m is None:
raise Exception("Can't check java version: no version string in output"
" of 'java -version': '{}'".format(output))
