Merge commit '8bfe2df23f8ed4d77f9832264e28479f08c193b2' into dev-release
diff --git a/build.gradle b/build.gradle
index 730d291..c47befd 100644
--- a/build.gradle
+++ b/build.gradle
@@ -35,7 +35,7 @@
ext {
androidSupportVersion = '25.4.0'
- asmVersion = '8.0' // When updating update tools/asmifier.py as well.
+ asmVersion = '8.0' // When updating update tools/asmifier.py and Toolhelper as well.
espressoVersion = '3.0.0'
fastutilVersion = '7.2.0'
guavaVersion = '23.0'
diff --git a/infra/config/global/cr-buildbucket.cfg b/infra/config/global/cr-buildbucket.cfg
index 87925c3..4fc504a 100644
--- a/infra/config/global/cr-buildbucket.cfg
+++ b/infra/config/global/cr-buildbucket.cfg
@@ -102,7 +102,7 @@
swarming_tags: "vpython:native-python-wrapper"
build_numbers: YES
recipe {
- properties: "mastername:internal.client.r8"
+ properties: "builder_group:internal.client.r8"
name: "rex"
}
mixins: "build_limited_scripts_slave recipe"
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 3651899..ab0d4dd 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -32,6 +32,7 @@
import com.android.tools.r8.naming.signature.GenericSignatureRewriter;
import com.android.tools.r8.origin.CommandLineOrigin;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.synthesis.SyntheticFinalization;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.CfgPrinter;
import com.android.tools.r8.utils.ExceptionUtils;
@@ -253,6 +254,12 @@
InspectorImpl.runInspections(options.outputInspections, appView.appInfo().classes());
if (options.isGeneratingClassFiles()) {
+ // TODO(b/158159959): Move this out so it is shared for both CF and DEX pipelines.
+ SyntheticFinalization.Result result =
+ appView.getSyntheticItems().computeFinalSynthetics(appView);
+ if (result != null) {
+ appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
+ }
new CfApplicationWriter(
appView,
marker,
@@ -283,15 +290,22 @@
appView, inputApp, options, executor, timing, appView.appInfo().app());
appView.setAppInfo(
new AppInfo(
- app,
- appView.appInfo().getMainDexClasses(),
- appView.appInfo().getSyntheticItems().commit(app)));
+ appView.appInfo().getSyntheticItems().commit(app),
+ appView.appInfo().getMainDexClasses()));
namingLens = NamingLens.getIdentityLens();
}
+
+ // TODO(b/158159959): Move this out so it is shared for both CF and DEX pipelines.
+ SyntheticFinalization.Result result =
+ appView.getSyntheticItems().computeFinalSynthetics(appView);
+ if (result != null) {
+ appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
+ }
+
new ApplicationWriter(
appView,
marker == null ? null : ImmutableList.copyOf(markers),
- GraphLens.getIdentityLens(),
+ appView.graphLens(),
InitClassLens.getDefault(),
namingLens,
null)
@@ -338,9 +352,8 @@
DexApplication cfApp = app.builder().replaceProgramClasses(nonDexProgramClasses).build();
appView.setAppInfo(
new AppInfo(
- cfApp,
- appView.appInfo().getMainDexClasses(),
- appView.appInfo().getSyntheticItems().commit(cfApp)));
+ appView.appInfo().getSyntheticItems().commit(cfApp),
+ appView.appInfo().getMainDexClasses()));
ConvertedCfFiles convertedCfFiles = new ConvertedCfFiles();
NamingLens prefixRewritingNamingLens =
PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index ef71e03..332b864 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -11,7 +11,6 @@
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.LazyLoadedDexApplication;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.desugar.PrefixRewritingMapper;
@@ -22,6 +21,7 @@
import com.android.tools.r8.origin.CommandLineOrigin;
import com.android.tools.r8.shaking.AnnotationRemover;
import com.android.tools.r8.shaking.L8TreePruner;
+import com.android.tools.r8.synthesis.SyntheticFinalization;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -99,11 +99,7 @@
});
assert !options.cfToCfDesugar;
if (shrink) {
- AndroidApp r8CommandInputApp = r8Command.getInputApp();
- InternalOptions r8CommandInternalOptions = r8Command.getInternalOptions();
- // TODO(b/167843161): Disable temporarily enum unboxing in L8 due to naming issues.
- r8CommandInternalOptions.enableEnumUnboxing = false;
- R8.runForTesting(r8CommandInputApp, r8CommandInternalOptions);
+ R8.run(r8Command, executorService);
} else if (d8Command != null) {
D8.run(d8Command, executorService);
}
@@ -131,15 +127,17 @@
new IRConverter(appView, timing).convert(appView, executor);
+ SyntheticFinalization.Result result =
+ appView.getSyntheticItems().computeFinalSynthetics(appView);
+ if (result != null) {
+ appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
+ }
+
NamingLens namingLens = PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
new GenericSignatureRewriter(appView, namingLens).run(appView.appInfo().classes(), executor);
new CfApplicationWriter(
- appView,
- options.getMarker(Tool.L8),
- GraphLens.getIdentityLens(),
- namingLens,
- null)
+ appView, options.getMarker(Tool.L8), appView.graphLens(), namingLens, null)
.write(options.getClassFileConsumer());
options.printWarnings();
} catch (ExecutionException e) {
diff --git a/src/main/java/com/android/tools/r8/PrintUses.java b/src/main/java/com/android/tools/r8/PrintUses.java
index 7ffc5ae..a1d8b26 100644
--- a/src/main/java/com/android/tools/r8/PrintUses.java
+++ b/src/main/java/com/android/tools/r8/PrintUses.java
@@ -6,6 +6,7 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexApplication;
@@ -352,7 +353,9 @@
new ApplicationReader(inputApp, options, new Timing("PrintUses")).read().toDirect();
appInfo =
AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
- application, MainDexClasses.createEmptyMainDexClasses());
+ application,
+ ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap(),
+ MainDexClasses.createEmptyMainDexClasses());
}
private void analyze() {
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 7b94e97..9963a47 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -57,7 +57,6 @@
import com.android.tools.r8.ir.optimize.UnusedArgumentsCollector;
import com.android.tools.r8.ir.optimize.UnusedArgumentsCollector.UnusedArgumentsGraphLens;
import com.android.tools.r8.ir.optimize.enums.EnumUnboxingCfMethods;
-import com.android.tools.r8.ir.optimize.enums.EnumUnboxingRewriter;
import com.android.tools.r8.ir.optimize.enums.EnumValueInfoMapCollector;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
import com.android.tools.r8.jar.CfApplicationWriter;
@@ -103,6 +102,7 @@
import com.android.tools.r8.shaking.VerticalClassMerger;
import com.android.tools.r8.shaking.VerticalClassMergerGraphLens;
import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
+import com.android.tools.r8.synthesis.SyntheticFinalization;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.CfgPrinter;
@@ -314,13 +314,7 @@
InterfaceMethodRewriter.checkForAssumedLibraryTypes(appView.appInfo(), options);
BackportedMethodRewriter.registerAssumedLibraryTypes(options);
if (options.enableEnumUnboxing) {
- if (appView.definitionFor(options.itemFactory.enumUnboxingUtilityType) != null) {
- // The enum unboxing utility class can be created only during cf to dex compilation.
- // If this is true, we are recompiling the dex application with R8 (compilation-steps).
- options.enableEnumUnboxing = false;
- } else {
- EnumUnboxingCfMethods.registerSynthesizedCodeReferences(options.itemFactory);
- }
+ EnumUnboxingCfMethods.registerSynthesizedCodeReferences(options.itemFactory);
}
List<ProguardConfigurationRule> synthesizedProguardRules = new ArrayList<>();
@@ -412,12 +406,6 @@
TreePruner pruner = new TreePruner(appViewWithLiveness);
DirectMappedDexApplication prunedApp = pruner.run();
- if (options.enableEnumUnboxing) {
- DexProgramClass utilityClass =
- EnumUnboxingRewriter.synthesizeEmptyEnumUnboxingUtilityClass(appView);
- prunedApp = prunedApp.builder().addProgramClass(utilityClass).build();
- }
-
// Recompute the subtyping information.
Set<DexType> removedClasses = pruner.getRemovedClasses();
appView.setAppInfo(
@@ -614,8 +602,9 @@
CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
try {
IRConverter converter = new IRConverter(appView, timing, printer, mainDexTracingResult);
- DexApplication application = converter.optimize(executorService).asDirect();
- appView.setAppInfo(appView.appInfo().rebuild(previous -> application));
+ DexApplication application =
+ converter.optimize(appViewWithLiveness, executorService).asDirect();
+ appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(previous -> application));
} finally {
timing.end();
}
@@ -818,6 +807,24 @@
}
}
+ // Add automatic main dex classes to an eventual manual list of classes.
+ if (!options.mainDexKeepRules.isEmpty()) {
+ appView.appInfo().getMainDexClasses().addAll(mainDexTracingResult);
+ }
+
+ SyntheticFinalization.Result result =
+ appView.getSyntheticItems().computeFinalSynthetics(appView);
+ if (result != null) {
+ if (appView.appInfo().hasLiveness()) {
+ appViewWithLiveness.setAppInfo(
+ appViewWithLiveness
+ .appInfo()
+ .rebuildWithLiveness(result.commit, result.removedSyntheticClasses));
+ } else {
+ appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(result.commit));
+ }
+ }
+
// Perform minification.
NamingLens namingLens;
if (options.getProguardConfiguration().hasApplyMappingFile()) {
@@ -871,11 +878,6 @@
assert !options.isShrinking();
}
- // Add automatic main dex classes to an eventual manual list of classes.
- if (!options.mainDexKeepRules.isEmpty()) {
- appView.appInfo().getMainDexClasses().addAll(mainDexTracingResult);
- }
-
// Validity checks.
assert getDirectApp(appView).verifyCodeObjectsOwners();
assert appView.appInfo().classes().stream().allMatch(clazz -> clazz.isValid(options));
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 6efe395..7c78db1 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -551,7 +551,7 @@
: getDesugaringState();
FeatureSplitConfiguration featureSplitConfiguration =
- !featureSplits.isEmpty() ? new FeatureSplitConfiguration(featureSplits, reporter) : null;
+ !featureSplits.isEmpty() ? new FeatureSplitConfiguration(featureSplits) : null;
R8Command command =
new R8Command(
diff --git a/src/main/java/com/android/tools/r8/ResourceShrinker.java b/src/main/java/com/android/tools/r8/ResourceShrinker.java
index 8174420..b01f9a3 100644
--- a/src/main/java/com/android/tools/r8/ResourceShrinker.java
+++ b/src/main/java/com/android/tools/r8/ResourceShrinker.java
@@ -168,7 +168,7 @@
processMethod(method);
}
- if (classDef.hasAnnotations()) {
+ if (classDef.hasClassOrMemberAnnotations()) {
processAnnotations(classDef);
}
}
diff --git a/src/main/java/com/android/tools/r8/bisect/Bisect.java b/src/main/java/com/android/tools/r8/bisect/Bisect.java
index 0dcca76..6a21762 100644
--- a/src/main/java/com/android/tools/r8/bisect/Bisect.java
+++ b/src/main/java/com/android/tools/r8/bisect/Bisect.java
@@ -14,6 +14,7 @@
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.GraphLens;
import com.android.tools.r8.graph.InitClassLens;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.utils.AndroidApp;
@@ -191,7 +192,7 @@
new ApplicationWriter(
AppView.createForD8(AppInfo.createInitialAppInfo(app)),
null,
- null,
+ GraphLens.getIdentityLens(),
InitClassLens.getDefault(),
NamingLens.getIdentityLens(),
null);
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 393297a..d9103a5 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -54,6 +54,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.utils.AndroidApiLevel;
import com.android.tools.r8.utils.DexVersion;
import com.android.tools.r8.utils.InternalOptions;
@@ -319,6 +320,7 @@
for (DexType type : mapping.getTypes()) {
if (type.isClassType()) {
assert DexString.isValidSimpleName(apiLevel, type.getName());
+ assert SyntheticItems.verifyNotInternalSynthetic(type);
}
}
@@ -1270,7 +1272,7 @@
public int getOffsetForAnnotationsDirectory(DexProgramClass clazz) {
- if (!clazz.hasAnnotations()) {
+ if (!clazz.hasClassOrMemberAnnotations()) {
return Constants.NO_OFFSET;
}
int offset = annotationDirectories.getInt(clazzToAnnotationDirectory.get(clazz));
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 5e31d99..2e0ab82 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.FeatureSplit;
import com.android.tools.r8.errors.DexFileOverflowDiagnostic;
import com.android.tools.r8.errors.InternalCompilerError;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexCallSite;
@@ -28,6 +29,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.utils.DescriptorUtils;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -74,6 +76,7 @@
private static final int MAX_PREFILL_ENTRIES = MAX_ENTRIES - 5000;
private final int id;
+ private final GraphLens graphLens;
private final VirtualFileIndexedItemCollection indexedItems;
private final IndexedItemTransaction transaction;
private final FeatureSplit featureSplit;
@@ -118,6 +121,7 @@
DexProgramClass primaryClass,
FeatureSplit featureSplit) {
this.id = id;
+ this.graphLens = graphLens;
this.indexedItems = new VirtualFileIndexedItemCollection(graphLens, initClassLens, namingLens);
this.transaction =
new IndexedItemTransaction(indexedItems, appView, graphLens, initClassLens, namingLens);
@@ -438,14 +442,20 @@
}
protected Map<FeatureSplit, Set<DexProgramClass>> removeFeatureSplitClassesGetMapping() {
- if (options.featureSplitConfiguration == null) {
+ assert appView.appInfo().hasClassHierarchy() == appView.enableWholeProgramOptimizations();
+ if (!appView.appInfo().hasClassHierarchy()) {
+ return ImmutableMap.of();
+ }
+
+ ClassToFeatureSplitMap classToFeatureSplitMap =
+ appView.appInfo().withClassHierarchy().getClassToFeatureSplitMap();
+ if (classToFeatureSplitMap.isEmpty()) {
return ImmutableMap.of();
}
// Pull out the classes that should go into feature splits.
Map<FeatureSplit, Set<DexProgramClass>> featureSplitClasses =
- options.featureSplitConfiguration.getFeatureSplitClasses(
- classes, appView.appInfo().app().getProguardMap());
+ classToFeatureSplitMap.getFeatureSplitClasses(classes);
if (featureSplitClasses.size() > 0) {
for (Set<DexProgramClass> featureClasses : featureSplitClasses.values()) {
classes.removeAll(featureClasses);
@@ -627,12 +637,12 @@
@Override
public boolean addField(DexField field) {
- return fields.add(field);
+ return fields.add(graphLens.lookupField(field));
}
@Override
public boolean addMethod(DexMethod method) {
- return methods.add(method);
+ return methods.add(graphLens.lookupMethod(method));
}
@Override
@@ -647,7 +657,9 @@
@Override
public boolean addType(DexType type) {
- return types.add(type);
+ DexType rewritten = graphLens.lookupType(type);
+ assert SyntheticItems.verifyNotInternalSynthetic(rewritten);
+ return types.add(rewritten);
}
@Override
@@ -684,18 +696,19 @@
@Override
public DexString getRenamedDescriptor(DexType type) {
- return namingLens.lookupDescriptor(type);
+ return namingLens.lookupDescriptor(graphLens.lookupType(type));
}
@Override
public DexString getRenamedName(DexMethod method) {
- assert namingLens.verifyRenamingConsistentWithResolution(method);
- return namingLens.lookupName(method);
+ DexMethod mappedMethod = graphLens.lookupMethod(method);
+ assert namingLens.verifyRenamingConsistentWithResolution(mappedMethod);
+ return namingLens.lookupName(mappedMethod);
}
@Override
public DexString getRenamedName(DexField field) {
- return namingLens.lookupName(field);
+ return namingLens.lookupName(graphLens.lookupField(field));
}
}
@@ -748,12 +761,12 @@
@Override
public boolean addField(DexField field) {
- return maybeInsert(field, fields, base.fields);
+ return maybeInsert(base.graphLens.lookupField(field), fields, base.fields);
}
@Override
public boolean addMethod(DexMethod method) {
- return maybeInsert(method, methods, base.methods);
+ return maybeInsert(base.graphLens.lookupMethod(method), methods, base.methods);
}
@Override
@@ -768,7 +781,9 @@
@Override
public boolean addType(DexType type) {
- return maybeInsert(type, types, base.types);
+ DexType rewritten = base.graphLens.lookupType(type);
+ assert SyntheticItems.verifyNotInternalSynthetic(rewritten);
+ return maybeInsert(rewritten, types, base.types);
}
@Override
@@ -793,18 +808,19 @@
@Override
public DexString getRenamedDescriptor(DexType type) {
- return namingLens.lookupDescriptor(type);
+ return namingLens.lookupDescriptor(base.graphLens.lookupType(type));
}
@Override
public DexString getRenamedName(DexMethod method) {
- assert namingLens.verifyRenamingConsistentWithResolution(method);
- return namingLens.lookupName(method);
+ DexMethod mappedMethod = base.graphLens.lookupMethod(method);
+ assert namingLens.verifyRenamingConsistentWithResolution(mappedMethod);
+ return namingLens.lookupName(mappedMethod);
}
@Override
public DexString getRenamedName(DexField field) {
- return namingLens.lookupName(field);
+ return namingLens.lookupName(base.graphLens.lookupField(field));
}
int getNumberOfMethods() {
diff --git a/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
new file mode 100644
index 0000000..6ba885d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.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.features;
+
+import com.android.tools.r8.FeatureSplit;
+import com.android.tools.r8.ProgramResource;
+import com.android.tools.r8.ProgramResourceProvider;
+import com.android.tools.r8.ResourceException;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+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.graph.GraphLens;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.Sets;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class ClassToFeatureSplitMap {
+
+ private final Map<DexType, FeatureSplit> classToFeatureSplitMap = new IdentityHashMap<>();
+
+ private ClassToFeatureSplitMap() {}
+
+ public static ClassToFeatureSplitMap createEmptyClassToFeatureSplitMap() {
+ return new ClassToFeatureSplitMap();
+ }
+
+ public static ClassToFeatureSplitMap createInitialClassToFeatureSplitMap(
+ AppView<? extends AppInfoWithClassHierarchy> appView) {
+ return createInitialClassToFeatureSplitMap(appView.options());
+ }
+
+ public static ClassToFeatureSplitMap createInitialClassToFeatureSplitMap(
+ InternalOptions options) {
+ DexItemFactory dexItemFactory = options.dexItemFactory();
+ FeatureSplitConfiguration featureSplitConfiguration = options.featureSplitConfiguration;
+
+ ClassToFeatureSplitMap result = new ClassToFeatureSplitMap();
+ if (featureSplitConfiguration == null) {
+ return result;
+ }
+
+ for (FeatureSplit featureSplit : featureSplitConfiguration.getFeatureSplits()) {
+ for (ProgramResourceProvider programResourceProvider :
+ featureSplit.getProgramResourceProviders()) {
+ try {
+ for (ProgramResource programResource : programResourceProvider.getProgramResources()) {
+ for (String classDescriptor : programResource.getClassDescriptors()) {
+ DexType type = dexItemFactory.createType(classDescriptor);
+ result.classToFeatureSplitMap.put(type, featureSplit);
+ }
+ }
+ } catch (ResourceException e) {
+ throw options.reporter.fatalError(e.getMessage());
+ }
+ }
+ }
+ return result;
+ }
+
+ public Map<FeatureSplit, Set<DexProgramClass>> getFeatureSplitClasses(
+ Set<DexProgramClass> classes) {
+ Map<FeatureSplit, Set<DexProgramClass>> result = new IdentityHashMap<>();
+ for (DexProgramClass clazz : classes) {
+ FeatureSplit featureSplit = getFeatureSplit(clazz);
+ if (featureSplit != null && !featureSplit.isBase()) {
+ result.computeIfAbsent(featureSplit, ignore -> Sets.newIdentityHashSet()).add(clazz);
+ }
+ }
+ return result;
+ }
+
+ public FeatureSplit getFeatureSplit(DexProgramClass clazz) {
+ return getFeatureSplit(clazz.getType());
+ }
+
+ public FeatureSplit getFeatureSplit(DexType type) {
+ return classToFeatureSplitMap.getOrDefault(type, FeatureSplit.BASE);
+ }
+
+ public boolean isEmpty() {
+ return classToFeatureSplitMap.isEmpty();
+ }
+
+ public boolean isInBase(DexProgramClass clazz) {
+ return getFeatureSplit(clazz).isBase();
+ }
+
+ public boolean isInBaseOrSameFeatureAs(DexProgramClass clazz, DexProgramClass context) {
+ FeatureSplit split = getFeatureSplit(clazz);
+ return split.isBase() || split == getFeatureSplit(context);
+ }
+
+ public boolean isInFeature(DexProgramClass clazz) {
+ return !isInBase(clazz);
+ }
+
+ public boolean isInSameFeatureOrBothInBase(ProgramMethod a, ProgramMethod b) {
+ return isInSameFeatureOrBothInBase(a.getHolder(), b.getHolder());
+ }
+
+ public boolean isInSameFeatureOrBothInBase(DexProgramClass a, DexProgramClass b) {
+ return getFeatureSplit(a) == getFeatureSplit(b);
+ }
+
+ public ClassToFeatureSplitMap rewrittenWithLens(GraphLens lens) {
+ ClassToFeatureSplitMap rewrittenClassToFeatureSplitMap = new ClassToFeatureSplitMap();
+ classToFeatureSplitMap.forEach(
+ (type, featureSplit) -> {
+ DexType rewrittenType = lens.lookupType(type);
+ if (rewrittenType.isIntType()) {
+ // The type was removed by enum unboxing.
+ return;
+ }
+ FeatureSplit existing =
+ rewrittenClassToFeatureSplitMap.classToFeatureSplitMap.put(
+ rewrittenType, featureSplit);
+ // If we map two classes to the same class then they must be from the same feature split.
+ assert existing == null || existing == featureSplit;
+ });
+ return rewrittenClassToFeatureSplitMap;
+ }
+
+ public ClassToFeatureSplitMap withoutPrunedClasses(Set<DexType> prunedClasses) {
+ ClassToFeatureSplitMap classToFeatureSplitMapAfterPruning = new ClassToFeatureSplitMap();
+ classToFeatureSplitMap.forEach(
+ (type, featureSplit) -> {
+ if (!prunedClasses.contains(type)) {
+ classToFeatureSplitMapAfterPruning.classToFeatureSplitMap.put(type, featureSplit);
+ }
+ });
+ return classToFeatureSplitMapAfterPruning;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/features/FeatureSplitConfiguration.java b/src/main/java/com/android/tools/r8/features/FeatureSplitConfiguration.java
index 6e5b2ab..c357177 100644
--- a/src/main/java/com/android/tools/r8/features/FeatureSplitConfiguration.java
+++ b/src/main/java/com/android/tools/r8/features/FeatureSplitConfiguration.java
@@ -6,63 +6,19 @@
import com.android.tools.r8.DataResourceConsumer;
import com.android.tools.r8.DataResourceProvider;
import com.android.tools.r8.FeatureSplit;
-import com.android.tools.r8.ProgramResource;
import com.android.tools.r8.ProgramResourceProvider;
-import com.android.tools.r8.ResourceException;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.naming.ClassNameMapper;
-import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.Reporter;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
-import java.util.IdentityHashMap;
import java.util.List;
-import java.util.Map;
import java.util.Set;
public class FeatureSplitConfiguration {
private final List<FeatureSplit> featureSplits;
- // TODO(141451259): Consider doing the mapping from DexType to Feature (with support in mapper).
- private final Map<String, FeatureSplit> javaTypeToFeatureSplitMapping = new HashMap<>();
-
- public FeatureSplitConfiguration(List<FeatureSplit> featureSplits, Reporter reporter) {
+ public FeatureSplitConfiguration(List<FeatureSplit> featureSplits) {
this.featureSplits = featureSplits;
- for (FeatureSplit featureSplit : featureSplits) {
- for (ProgramResourceProvider programResourceProvider :
- featureSplit.getProgramResourceProviders()) {
- try {
- for (ProgramResource programResource : programResourceProvider.getProgramResources()) {
- for (String classDescriptor : programResource.getClassDescriptors()) {
- javaTypeToFeatureSplitMapping.put(
- DescriptorUtils.descriptorToJavaType(classDescriptor), featureSplit);
- }
- }
- } catch (ResourceException e) {
- throw reporter.fatalError(e.getMessage());
- }
- }
- }
- }
-
- public Map<FeatureSplit, Set<DexProgramClass>> getFeatureSplitClasses(
- Set<DexProgramClass> classes, ClassNameMapper mapper) {
- Map<FeatureSplit, Set<DexProgramClass>> result = new IdentityHashMap<>();
-
- for (DexProgramClass programClass : classes) {
- String originalClassName =
- DescriptorUtils.descriptorToJavaType(programClass.type.toDescriptorString(), mapper);
- FeatureSplit featureSplit = javaTypeToFeatureSplitMapping.get(originalClassName);
- if (featureSplit != null) {
- result.computeIfAbsent(featureSplit, f -> Sets.newIdentityHashSet()).add(programClass);
- }
- }
- return result;
}
public static class DataResourceProvidersAndConsumer {
@@ -108,37 +64,7 @@
return result;
}
- public boolean inBaseOrSameFeatureAs(DexProgramClass clazz, DexProgramClass context) {
- FeatureSplit split = getFeatureSplit(clazz);
- return split.isBase() || split == getFeatureSplit(context);
- }
-
- public boolean isInFeature(DexProgramClass clazz) {
- return !isInBase(clazz);
- }
-
- public boolean isInBase(DexProgramClass clazz) {
- return getFeatureSplit(clazz).isBase();
- }
-
- public boolean inSameFeatureOrBothInBase(ProgramMethod a, ProgramMethod b) {
- return inSameFeatureOrBothInBase(a.getHolder(), b.getHolder());
- }
-
- public boolean inSameFeatureOrBothInBase(DexProgramClass a, DexProgramClass b) {
- return getFeatureSplit(a) == getFeatureSplit(b);
- }
-
public List<FeatureSplit> getFeatureSplits() {
return featureSplits;
}
-
- public FeatureSplit getFeatureSplitFromClassDescriptor(String classDescriptor) {
- return javaTypeToFeatureSplitMapping.get(DescriptorUtils.descriptorToJavaType(classDescriptor));
- }
-
- public FeatureSplit getFeatureSplit(DexProgramClass clazz) {
- return javaTypeToFeatureSplitMapping.getOrDefault(
- clazz.type.toSourceString(), FeatureSplit.BASE);
- }
}
diff --git a/src/main/java/com/android/tools/r8/graph/AccessControl.java b/src/main/java/com/android/tools/r8/graph/AccessControl.java
index 788b358..4bb68b9 100644
--- a/src/main/java/com/android/tools/r8/graph/AccessControl.java
+++ b/src/main/java/com/android/tools/r8/graph/AccessControl.java
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
-import com.android.tools.r8.features.FeatureSplitConfiguration;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.utils.OptionalBool;
/**
@@ -15,21 +15,18 @@
public class AccessControl {
public static OptionalBool isClassAccessible(
- DexClass clazz, ProgramMethod context, AppView<?> appView) {
+ DexClass clazz, ProgramMethod context, AppView<? extends AppInfoWithClassHierarchy> appView) {
return isClassAccessible(
- clazz, context.getHolder(), appView.options().featureSplitConfiguration);
+ clazz, context.getHolder(), appView.appInfo().getClassToFeatureSplitMap());
}
public static OptionalBool isClassAccessible(
- DexClass clazz,
- DexProgramClass context,
- FeatureSplitConfiguration featureSplitConfiguration) {
+ DexClass clazz, DexProgramClass context, ClassToFeatureSplitMap classToFeatureSplitMap) {
if (!clazz.isPublic() && !clazz.getType().isSamePackage(context.getType())) {
return OptionalBool.FALSE;
}
- if (featureSplitConfiguration != null
- && clazz.isProgramClass()
- && !featureSplitConfiguration.inBaseOrSameFeatureAs(clazz.asProgramClass(), context)) {
+ if (clazz.isProgramClass()
+ && !classToFeatureSplitMap.isInBaseOrSameFeatureAs(clazz.asProgramClass(), context)) {
return OptionalBool.UNKNOWN;
}
return OptionalBool.TRUE;
@@ -73,7 +70,7 @@
DexProgramClass context,
AppInfoWithClassHierarchy appInfo) {
OptionalBool classAccessibility =
- isClassAccessible(holder, context, appInfo.options().featureSplitConfiguration);
+ isClassAccessible(holder, context, appInfo.getClassToFeatureSplitMap());
if (classAccessibility.isFalse()) {
return OptionalBool.FALSE;
}
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 c49eb28..6da4e08 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -3,12 +3,13 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy.CreateDesugaringViewOnAppInfo;
import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.synthesis.CommittedItems;
+import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.BooleanBox;
import com.android.tools.r8.utils.InternalOptions;
import java.util.Collection;
@@ -31,30 +32,28 @@
public static AppInfo createInitialAppInfo(
DexApplication application, MainDexClasses mainDexClasses) {
return new AppInfo(
- application,
- mainDexClasses,
- SyntheticItems.createInitialSyntheticItems(),
- new BooleanBox());
+ SyntheticItems.createInitialSyntheticItems().commit(application), mainDexClasses);
}
- public AppInfo(
- DexApplication application,
- MainDexClasses mainDexClasses,
- SyntheticItems.CommittedItems committedItems) {
- this(application, mainDexClasses, committedItems.toSyntheticItems(), new BooleanBox());
+ public AppInfo(CommittedItems committedItems, MainDexClasses mainDexClasses) {
+ this(
+ committedItems.getApplication(),
+ committedItems.toSyntheticItems(),
+ mainDexClasses,
+ new BooleanBox());
}
// For desugaring.
// This is a view onto the app info and is the only place the pending synthetics are shared.
- AppInfo(CreateDesugaringViewOnAppInfo witness, AppInfo appInfo) {
- this(appInfo.app, appInfo.mainDexClasses, appInfo.syntheticItems, appInfo.obsolete);
+ AppInfo(AppInfoWithClassHierarchy.CreateDesugaringViewOnAppInfo witness, AppInfo appInfo) {
+ this(appInfo.app, appInfo.syntheticItems, appInfo.mainDexClasses, appInfo.obsolete);
assert witness != null;
}
private AppInfo(
DexApplication application,
- MainDexClasses mainDexClasses,
SyntheticItems syntheticItems,
+ MainDexClasses mainDexClasses,
BooleanBox obsolete) {
this.app = application;
this.dexItemFactory = application.dexItemFactory;
@@ -105,7 +104,7 @@
public void addSynthesizedClass(DexProgramClass clazz, boolean addToMainDexClasses) {
assert checkIfObsolete();
- syntheticItems.addSyntheticClass(clazz);
+ syntheticItems.addLegacySyntheticClass(clazz);
if (addToMainDexClasses && !mainDexClasses.isEmpty()) {
mainDexClasses.add(clazz);
}
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 68ce78b..a1e3d15 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.TraversalContinuation.BREAK;
import static com.android.tools.r8.utils.TraversalContinuation.CONTINUE;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.FieldResolutionResult.SuccessfulFieldResolutionResult;
import com.android.tools.r8.graph.ResolutionResult.ArrayCloneMethodResult;
import com.android.tools.r8.graph.ResolutionResult.ClassNotFoundResult;
@@ -16,6 +17,8 @@
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.shaking.MainDexClasses;
+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.SetUtils;
import com.android.tools.r8.utils.TraversalContinuation;
@@ -47,24 +50,30 @@
}
public static AppInfoWithClassHierarchy createInitialAppInfoWithClassHierarchy(
- DexApplication application, MainDexClasses mainDexClasses) {
+ DexApplication application,
+ ClassToFeatureSplitMap classToFeatureSplitMap,
+ MainDexClasses mainDexClasses) {
return new AppInfoWithClassHierarchy(
- application,
- mainDexClasses,
- SyntheticItems.createInitialSyntheticItems().commit(application));
+ SyntheticItems.createInitialSyntheticItems().commit(application),
+ classToFeatureSplitMap,
+ mainDexClasses);
}
- // For AppInfoWithLiveness.
+ private final ClassToFeatureSplitMap classToFeatureSplitMap;
+
+ // For AppInfoWithLiveness subclass.
protected AppInfoWithClassHierarchy(
- DexApplication application,
- MainDexClasses mainDexClasses,
- SyntheticItems.CommittedItems committedItems) {
- super(application, mainDexClasses, committedItems);
+ CommittedItems committedItems,
+ ClassToFeatureSplitMap classToFeatureSplitMap,
+ MainDexClasses mainDexClasses) {
+ super(committedItems, mainDexClasses);
+ this.classToFeatureSplitMap = classToFeatureSplitMap;
}
// For desugaring.
private AppInfoWithClassHierarchy(CreateDesugaringViewOnAppInfo witness, AppInfo appInfo) {
super(witness, appInfo);
+ this.classToFeatureSplitMap = ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap();
}
public static AppInfoWithClassHierarchy createForDesugaring(AppInfo appInfo) {
@@ -72,10 +81,20 @@
return new AppInfoWithClassHierarchy(WITNESS, appInfo);
}
- public AppInfoWithClassHierarchy rebuild(Function<DexApplication, DexApplication> fn) {
- DexApplication application = fn.apply(app());
+ public final AppInfoWithClassHierarchy rebuildWithClassHierarchy(CommittedItems commit) {
+ return new AppInfoWithClassHierarchy(commit, getClassToFeatureSplitMap(), getMainDexClasses());
+ }
+
+ public AppInfoWithClassHierarchy rebuildWithClassHierarchy(
+ Function<DexApplication, DexApplication> fn) {
return new AppInfoWithClassHierarchy(
- application, getMainDexClasses(), getSyntheticItems().commit(application));
+ getSyntheticItems().commit(fn.apply(app())),
+ getClassToFeatureSplitMap(),
+ getMainDexClasses());
+ }
+
+ public ClassToFeatureSplitMap getClassToFeatureSplitMap() {
+ return classToFeatureSplitMap;
}
@Override
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 f853b30..de7599a 100644
--- a/src/main/java/com/android/tools/r8/graph/AppServices.java
+++ b/src/main/java/com/android/tools/r8/graph/AppServices.java
@@ -12,7 +12,9 @@
import com.android.tools.r8.ProgramResourceProvider;
import com.android.tools.r8.ResourceException;
import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.StringUtils;
@@ -71,8 +73,10 @@
return builder.build();
}
- public boolean hasServiceImplementationsInFeature(DexType serviceType) {
- if (appView.options().featureSplitConfiguration == null) {
+ public boolean hasServiceImplementationsInFeature(
+ AppView<AppInfoWithLiveness> appView, DexType serviceType) {
+ ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
+ if (classToFeatureSplitMap.isEmpty()) {
return false;
}
Map<FeatureSplit, List<DexType>> featureImplementations = services.get(serviceType);
@@ -89,12 +93,12 @@
}
// Check if service is defined feature
DexProgramClass serviceClass = appView.definitionForProgramType(serviceType);
- if (appView.options().featureSplitConfiguration.isInFeature(serviceClass)) {
+ if (classToFeatureSplitMap.isInFeature(serviceClass)) {
return true;
}
for (DexType dexType : featureImplementations.get(FeatureSplit.BASE)) {
DexProgramClass implementationClass = appView.definitionForProgramType(dexType);
- if (appView.options().featureSplitConfiguration.isInFeature(implementationClass)) {
+ if (classToFeatureSplitMap.isInFeature(implementationClass)) {
return true;
}
}
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 2a181bc..f89f265 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.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.DexValue.DexValueString;
import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis.InitializedClassesInInstanceMethods;
@@ -27,6 +28,7 @@
import com.android.tools.r8.shaking.LibraryModeledPredicate;
import com.android.tools.r8.shaking.MainDexClasses;
import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
+import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.ThrowingConsumer;
@@ -135,9 +137,11 @@
public static AppView<AppInfoWithClassHierarchy> createForR8(
DexApplication application, MainDexClasses mainDexClasses) {
+ ClassToFeatureSplitMap classToFeatureSplitMap =
+ ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(application.options);
AppInfoWithClassHierarchy appInfo =
AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
- application, mainDexClasses);
+ application, classToFeatureSplitMap, mainDexClasses);
return new AppView<>(
appInfo, WholeProgramOptimizations.ON, defaultPrefixRewritingMapper(appInfo));
}
@@ -266,6 +270,10 @@
return wholeProgramOptimizations == WholeProgramOptimizations.ON;
}
+ public SyntheticItems getSyntheticItems() {
+ return appInfo.getSyntheticItems();
+ }
+
public CallSiteOptimizationInfoPropagator callSiteOptimizationInfoPropagator() {
return callSiteOptimizationInfoPropagator;
}
@@ -358,6 +366,10 @@
return initClassLens;
}
+ public boolean hasInitClassLens() {
+ return initClassLens != null;
+ }
+
public void setInitClassLens(InitClassLens initClassLens) {
this.initClassLens = initClassLens;
}
@@ -514,6 +526,11 @@
}
}
+ public void rewriteWithApplication(DirectMappedDexApplication application) {
+ assert application != null;
+ rewriteWithLens(null, application, withLiveness());
+ }
+
public void rewriteWithLensAndApplication(
NestedGraphLens lens, DirectMappedDexApplication application) {
assert lens != null;
@@ -525,9 +542,14 @@
NestedGraphLens lens,
DirectMappedDexApplication application,
AppView<AppInfoWithLiveness> appView) {
- boolean changed = appView.setGraphLens(lens);
- assert changed;
- assert application.verifyWithLens(lens);
+ if (lens != null) {
+ boolean changed = appView.setGraphLens(lens);
+ assert changed;
+ assert application.verifyWithLens(lens);
+ }
appView.setAppInfo(appView.appInfo().rewrittenWithLens(application, lens));
+ if (appView.hasInitClassLens()) {
+ appView.setInitClassLens(appView.initClassLens().rewrittenWithLens(lens));
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/graph/DefaultInitClassLens.java b/src/main/java/com/android/tools/r8/graph/DefaultInitClassLens.java
index 56a1733..ec2f4c6 100644
--- a/src/main/java/com/android/tools/r8/graph/DefaultInitClassLens.java
+++ b/src/main/java/com/android/tools/r8/graph/DefaultInitClassLens.java
@@ -20,4 +20,9 @@
public DexField getInitClassField(DexType type) {
throw new Unreachable("Unexpected InitClass instruction for `" + type.toSourceString() + "`");
}
+
+ @Override
+ public InitClassLens rewrittenWithLens(GraphLens lens) {
+ return this;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexAnnotationElement.java b/src/main/java/com/android/tools/r8/graph/DexAnnotationElement.java
index e1965be..237838f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexAnnotationElement.java
+++ b/src/main/java/com/android/tools/r8/graph/DexAnnotationElement.java
@@ -17,6 +17,10 @@
this.value = value;
}
+ public DexValue getValue() {
+ return value;
+ }
+
@Override
public int hashCode() {
return name.hashCode() + value.hashCode() * 3;
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 67870ab..516edc0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DexApplication.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.dex.ApplicationReader.ProgramClassConflictResolver;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.synthesis.SyntheticDefinitionsProvider;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.ProgramClassCollection;
import com.android.tools.r8.utils.Timing;
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 528b79b..e3bf2d8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -723,6 +723,10 @@
return enclosingMethod;
}
+ public void setEnclosingMethodAttribute(EnclosingMethodAttribute enclosingMethod) {
+ this.enclosingMethod = enclosingMethod;
+ }
+
public void clearEnclosingMethodAttribute() {
enclosingMethod = null;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexDefinitionSupplier.java b/src/main/java/com/android/tools/r8/graph/DexDefinitionSupplier.java
index 9391a83..4125ca0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDefinitionSupplier.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDefinitionSupplier.java
@@ -48,6 +48,10 @@
return DexProgramClass.asProgramClassOrNull(definitionFor(type, context));
}
+ default DexProgramClass programDefinitionFor(DexType type, ProgramMethod context) {
+ return programDefinitionFor(type, context.getHolder());
+ }
+
default <D extends DexEncodedMember<D, R>, R extends DexMember<D, R>>
DexClass definitionForHolder(DexEncodedMember<D, R> member, ProgramMethod context) {
return definitionForHolder(member.toReference(), context.getHolder());
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedAnnotation.java b/src/main/java/com/android/tools/r8/graph/DexEncodedAnnotation.java
index 0ed6769..e480799 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedAnnotation.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedAnnotation.java
@@ -30,6 +30,14 @@
}
}
+ public DexAnnotationElement getElement(int i) {
+ return elements[i];
+ }
+
+ public int getNumberOfElements() {
+ return elements.length;
+ }
+
@Override
void collectMixedSectionItems(MixedSectionCollection mixedItems) {
// Should never be called.
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 2ca1b48..c40383d 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -73,11 +73,13 @@
import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.Pair;
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;
import java.util.Arrays;
import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
@@ -268,6 +270,41 @@
assert parameterAnnotationsList != null;
}
+ public void hashSyntheticContent(Hasher hasher) {
+ // Method holder does not contribute to the synthetic hash (it is freely chosen).
+ // Method name does not contribute to the synthetic hash (it is freely chosen).
+ method.proto.hashSyntheticContent(hasher);
+ hasher.putInt(accessFlags.getAsCfAccessFlags());
+ assert annotations().isEmpty();
+ assert parameterAnnotationsList.isEmpty();
+ assert code != null;
+ // TODO(b/158159959): Implement a more precise hashing on code objects.
+ if (code.isCfCode()) {
+ CfCode cfCode = code.asCfCode();
+ hasher.putInt(cfCode.instructions.size());
+ for (CfInstruction instruction : cfCode.instructions) {
+ hasher.putInt(instruction.getClass().hashCode());
+ }
+ } else {
+ assert code.isDexCode();
+ hasher.putInt(code.hashCode());
+ }
+ }
+
+ public boolean isSyntheticContentEqual(DexEncodedMethod other) {
+ return syntheticCompareTo(other) == 0;
+ }
+
+ public int syntheticCompareTo(DexEncodedMethod other) {
+ assert annotations().isEmpty();
+ assert parameterAnnotationsList.isEmpty();
+ return Comparator.comparing(DexEncodedMethod::proto, DexProto::slowCompareTo)
+ .thenComparingInt(m -> m.accessFlags.getAsCfAccessFlags())
+ // TODO(b/158159959): Implement structural compareTo on code.
+ .thenComparing(m -> m.getCode().toString())
+ .compare(this, other);
+ }
+
public DexType getHolderType() {
return getReference().holder;
}
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 19b793d..a58ec39 100644
--- a/src/main/java/com/android/tools/r8/graph/DexField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexField.java
@@ -13,12 +13,10 @@
public class DexField extends DexMember<DexEncodedField, DexField> {
public final DexType type;
- public final DexString name;
DexField(DexType holder, DexType type, DexString name, boolean skipNameValidationForTesting) {
- super(holder);
+ super(holder, name);
this.type = type;
- this.name = name;
if (!skipNameValidationForTesting && !name.isValidFieldName()) {
throw new CompilationError(
"Field name '" + name.toString() + "' cannot be represented in dex format.");
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 91a70a9..4c3779e 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -28,7 +28,6 @@
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.optimize.enums.EnumUnboxingRewriter;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.utils.ArrayUtils;
import com.android.tools.r8.utils.LRUCacheTable;
@@ -443,12 +442,6 @@
createString("L" + NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME + ";");
public final DexType nestConstructorType = createStaticallyKnownType(nestConstructorDescriptor);
- public final DexString enumUnboxingUtilityDescriptor =
- createString(
- "Lcom/android/tools/r8/" + EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_CLASS_NAME + ";");
- public final DexType enumUnboxingUtilityType =
- createStaticallyKnownType(enumUnboxingUtilityDescriptor);
-
public final StringBuildingMethods stringBuilderMethods =
new StringBuildingMethods(stringBuilderType);
public final StringBuildingMethods stringBufferMethods =
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 02fd431..2a429d6 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMember.java
@@ -7,10 +7,13 @@
extends DexReference implements PresortedComparable<R> {
public final DexType holder;
+ public final DexString name;
- public DexMember(DexType holder) {
+ public DexMember(DexType holder, DexString name) {
assert holder != null;
this.holder = holder;
+ assert name != null;
+ this.name = name;
}
public DexEncodedMember<?, ?> lookupOnClass(DexClass clazz) {
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 493bea3..26f114f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -18,12 +18,10 @@
public class DexMethod extends DexMember<DexEncodedMethod, DexMethod> {
public final DexProto proto;
- public final DexString name;
DexMethod(DexType holder, DexProto proto, DexString name, boolean skipNameValidationForTesting) {
- super(holder);
+ super(holder, name);
this.proto = proto;
- this.name = name;
if (!skipNameValidationForTesting && !name.isValidMethodName()) {
throw new CompilationError(
"Method name '" + name + "' in class '" + holder.toSourceString() +
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 a285398..f0efe20 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -269,7 +269,7 @@
void collectMixedSectionItems(MixedSectionCollection mixedItems) {
assert getEnclosingMethodAttribute() == null;
assert getInnerClasses().isEmpty();
- if (hasAnnotations()) {
+ if (hasClassOrMemberAnnotations()) {
mixedItems.setAnnotationsDirectoryForClass(this, new DexAnnotationDirectory(this));
}
}
@@ -363,7 +363,8 @@
return hasMethods() || hasFields();
}
- public boolean hasAnnotations() {
+ /** Determine if the class or any of its methods/fields has any attributes. */
+ public boolean hasClassOrMemberAnnotations() {
return !annotations().isEmpty()
|| hasAnnotations(methodCollection)
|| hasAnnotations(staticFields)
diff --git a/src/main/java/com/android/tools/r8/graph/DexProto.java b/src/main/java/com/android/tools/r8/graph/DexProto.java
index 77b9c42..09985c3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProto.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProto.java
@@ -5,6 +5,7 @@
import com.android.tools.r8.dex.IndexedItemCollection;
import com.android.tools.r8.naming.NamingLens;
+import com.google.common.hash.Hasher;
public class DexProto extends IndexedDexItem implements PresortedComparable<DexProto> {
@@ -97,4 +98,11 @@
builder.append(lens.lookupDescriptor(returnType));
return builder.toString();
}
+
+ public void hashSyntheticContent(Hasher hasher) {
+ hasher.putInt(returnType.hashCode());
+ for (DexType param : parameters.values) {
+ hasher.putInt(param.hashCode());
+ }
+ }
}
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 fc14405..bc7e26f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -11,7 +11,7 @@
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.EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_CLASS_NAME;
+import static com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX;
import com.android.tools.r8.dex.IndexedItemCollection;
import com.android.tools.r8.errors.Unreachable;
@@ -22,6 +22,7 @@
import com.android.tools.r8.ir.optimize.ServiceLoaderRewriter;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
import com.google.common.base.Predicates;
@@ -291,6 +292,9 @@
return
// Hygienic suffix.
name.contains(COMPANION_CLASS_NAME_SUFFIX)
+ // New and hygienic synthesis infrastructure.
+ || name.contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
+ || name.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
// Only generated in core lib.
|| name.contains(EMULATE_LIBRARY_CLASS_NAME_SUFFIX)
|| name.contains(TYPE_WRAPPER_SUFFIX)
@@ -308,7 +312,7 @@
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(ENUM_UNBOXING_UTILITY_CLASS_NAME) // Global singleton.
+ return name.contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX) // Shared among enums.
|| name.contains(LAMBDA_CLASS_NAME_PREFIX) // Could collide.
|| name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
|| name.contains(DISPATCH_CLASS_NAME_SUFFIX) // Shared on reference.
diff --git a/src/main/java/com/android/tools/r8/graph/FinalInitClassLens.java b/src/main/java/com/android/tools/r8/graph/FinalInitClassLens.java
index 4f0a854..07e4dc2 100644
--- a/src/main/java/com/android/tools/r8/graph/FinalInitClassLens.java
+++ b/src/main/java/com/android/tools/r8/graph/FinalInitClassLens.java
@@ -28,4 +28,16 @@
public boolean isFinal() {
return true;
}
+
+ @Override
+ public InitClassLens rewrittenWithLens(GraphLens lens) {
+ InitClassLens.Builder builder = InitClassLens.builder();
+ mapping.forEach(
+ (type, field) -> {
+ DexType rewrittenType = lens.lookupType(type);
+ DexField rewrittenField = lens.lookupField(field);
+ builder.map(rewrittenType, rewrittenField);
+ });
+ return builder.build();
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/InitClassLens.java b/src/main/java/com/android/tools/r8/graph/InitClassLens.java
index cac3870..e3e7fd2 100644
--- a/src/main/java/com/android/tools/r8/graph/InitClassLens.java
+++ b/src/main/java/com/android/tools/r8/graph/InitClassLens.java
@@ -23,6 +23,8 @@
return false;
}
+ public abstract InitClassLens rewrittenWithLens(GraphLens lens);
+
public static class Builder {
private final Map<DexType, DexField> mapping = new ConcurrentHashMap<>();
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
index ecc7505..9839a80 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
@@ -55,6 +55,7 @@
Collection<DexCallSite> callSites,
Collection<DexMethodHandle> methodHandles) {
assert appInfo != null;
+ assert graphLens != null;
assert classes != null;
assert protos != null;
assert types != null;
@@ -251,11 +252,11 @@
}
public int getOffsetFor(DexField field) {
- return getOffsetFor(field, fields);
+ return getOffsetFor(graphLens.lookupField(field), fields);
}
public int getOffsetFor(DexMethod method) {
- return getOffsetFor(method, methods);
+ return getOffsetFor(graphLens.lookupMethod(method), methods);
}
public int getOffsetFor(DexString string) {
@@ -263,7 +264,7 @@
}
public int getOffsetFor(DexType type) {
- return getOffsetFor(type, types);
+ return getOffsetFor(graphLens.lookupType(type), types);
}
public int getOffsetFor(DexCallSite callSite) {
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramPackage.java b/src/main/java/com/android/tools/r8/graph/ProgramPackage.java
index c244576..c92c6d4 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramPackage.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramPackage.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.Iterator;
import java.util.Set;
@@ -18,9 +19,9 @@
this.packageDescriptor = packageDescriptor;
}
- public void add(DexProgramClass clazz) {
+ public boolean add(DexProgramClass clazz) {
assert clazz.getType().getPackageDescriptor().equals(packageDescriptor);
- classes.add(clazz);
+ return classes.add(clazz);
}
public String getLastPackageName() {
@@ -43,6 +44,10 @@
forEach(clazz -> clazz.forEachProgramMethod(consumer));
}
+ public Set<DexProgramClass> classesInPackage() {
+ return ImmutableSet.copyOf(classes);
+ }
+
@Override
public Iterator<DexProgramClass> iterator() {
return classes.iterator();
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramPackageCollection.java b/src/main/java/com/android/tools/r8/graph/ProgramPackageCollection.java
index 57fc75a..fe9a64c 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramPackageCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramPackageCollection.java
@@ -16,15 +16,27 @@
this.packages = packages;
}
- public static ProgramPackageCollection create(AppView<?> appView) {
- Map<String, ProgramPackage> packages = new HashMap<>();
+ public static ProgramPackageCollection createWithAllProgramClasses(AppView<?> appView) {
assert !appView.appInfo().getSyntheticItems().hasPendingSyntheticClasses();
+ ProgramPackageCollection programPackages = new ProgramPackageCollection(new HashMap<>());
for (DexProgramClass clazz : appView.appInfo().classes()) {
- packages
- .computeIfAbsent(clazz.getType().getPackageDescriptor(), ProgramPackage::new)
- .add(clazz);
+ programPackages.addProgramClass(clazz);
}
- return new ProgramPackageCollection(packages);
+ return programPackages;
+ }
+
+ public static ProgramPackageCollection createEmpty() {
+ return new ProgramPackageCollection(new HashMap<>());
+ }
+
+ public boolean addProgramClass(DexProgramClass clazz) {
+ return packages
+ .computeIfAbsent(clazz.getType().getPackageDescriptor(), ProgramPackage::new)
+ .add(clazz);
+ }
+
+ public boolean isEmpty() {
+ return packages.isEmpty();
}
@Override
diff --git a/src/main/java/com/android/tools/r8/graph/SyntheticItems.java b/src/main/java/com/android/tools/r8/graph/SyntheticItems.java
deleted file mode 100644
index 3df048f..0000000
--- a/src/main/java/com/android/tools/r8/graph/SyntheticItems.java
+++ /dev/null
@@ -1,112 +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.graph;
-
-import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Function;
-
-public class SyntheticItems implements SyntheticDefinitionsProvider {
-
- public static class CommittedItems implements SyntheticDefinitionsProvider {
- // Set of all types that represent synthesized items.
- private final ImmutableSet<DexType> syntheticTypes;
-
- private CommittedItems(ImmutableSet<DexType> syntheticTypes) {
- this.syntheticTypes = syntheticTypes;
- }
-
- SyntheticItems toSyntheticItems() {
- return new SyntheticItems(syntheticTypes);
- }
-
- @Override
- public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
- return baseDefinitionFor.apply(type);
- }
- }
-
- // Thread safe collection of synthesized classes that are not yet committed to the application.
- private final Map<DexType, DexProgramClass> pendingClasses = new ConcurrentHashMap<>();
-
- // Immutable set of types that represent synthetic definitions in the application (eg, committed).
- private final ImmutableSet<DexType> syntheticTypes;
-
- private SyntheticItems(ImmutableSet<DexType> syntheticTypes) {
- this.syntheticTypes = syntheticTypes;
- }
-
- public static SyntheticItems createInitialSyntheticItems() {
- return new SyntheticItems(ImmutableSet.of());
- }
-
- public boolean hasPendingSyntheticClasses() {
- return !pendingClasses.isEmpty();
- }
-
- public Collection<DexProgramClass> getPendingSyntheticClasses() {
- return Collections.unmodifiableCollection(pendingClasses.values());
- }
-
- @Override
- public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
- DexProgramClass pending = pendingClasses.get(type);
- if (pending != null) {
- assert baseDefinitionFor.apply(type) == null
- : "Pending synthetic definition also present in the active program: " + type;
- return pending;
- }
- return baseDefinitionFor.apply(type);
- }
-
- // TODO(b/158159959): Remove the usage of this direct class addition (and name-based id).
- public void addSyntheticClass(DexProgramClass clazz) {
- assert clazz.type.isD8R8SynthesizedClassType();
- assert !syntheticTypes.contains(clazz.type);
- DexProgramClass previous = pendingClasses.put(clazz.type, clazz);
- assert previous == null || previous == clazz;
- }
-
- public boolean isSyntheticClass(DexType type) {
- return syntheticTypes.contains(type)
- || pendingClasses.containsKey(type)
- // TODO(b/158159959): Remove usage of name-based identification.
- || type.isD8R8SynthesizedClassType();
- }
-
- public boolean isSyntheticClass(DexProgramClass clazz) {
- return isSyntheticClass(clazz.type);
- }
-
- public CommittedItems commit(DexApplication application) {
- assert verifyAllPendingSyntheticsAreInApp(application, this);
- // All synthetics are in the app proper and no further meta-data is present so the empty
- // collection is currently returned here.
- ImmutableSet<DexType> merged = syntheticTypes;
- if (!pendingClasses.isEmpty()) {
- merged =
- ImmutableSet.<DexType>builder()
- .addAll(syntheticTypes)
- .addAll(pendingClasses.keySet())
- .build();
- }
- return new CommittedItems(merged);
- }
-
- public CommittedItems commit(DexApplication application, NestedGraphLens lens) {
- return new CommittedItems(lens.rewriteTypes(commit(application).syntheticTypes));
- }
-
- private static boolean verifyAllPendingSyntheticsAreInApp(
- DexApplication app, SyntheticItems synthetics) {
- for (DexProgramClass clazz : synthetics.getPendingSyntheticClasses()) {
- assert app.programDefinitionFor(clazz.type) != null;
- }
- return true;
- }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index a938abb..8b17c78 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -6,12 +6,16 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.policies.NoAnnotations;
import com.android.tools.r8.horizontalclassmerging.policies.NoFields;
+import com.android.tools.r8.horizontalclassmerging.policies.NoInnerClasses;
import com.android.tools.r8.horizontalclassmerging.policies.NoInterfaces;
-import com.android.tools.r8.horizontalclassmerging.policies.NoInternalUtilityClasses;
+import com.android.tools.r8.horizontalclassmerging.policies.NoKeepRules;
import com.android.tools.r8.horizontalclassmerging.policies.NoRuntimeTypeChecks;
import com.android.tools.r8.horizontalclassmerging.policies.NoStaticClassInitializer;
import com.android.tools.r8.horizontalclassmerging.policies.NotEntryPoint;
+import com.android.tools.r8.horizontalclassmerging.policies.NotMatchedByNoHorizontalClassMerging;
+import com.android.tools.r8.horizontalclassmerging.policies.RespectPackageBoundaries;
import com.android.tools.r8.horizontalclassmerging.policies.SameParentClass;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.ClassMergingEnqueuerExtension;
@@ -36,14 +40,18 @@
List<Policy> policies =
ImmutableList.of(
+ new NotMatchedByNoHorizontalClassMerging(appView),
new NoFields(),
// TODO(b/166071504): Allow merging of classes that implement interfaces.
new NoInterfaces(),
+ new NoAnnotations(),
+ new NoInnerClasses(),
new NoStaticClassInitializer(),
+ new NoKeepRules(appView),
new NoRuntimeTypeChecks(classMergingEnqueuerExtension),
new NotEntryPoint(appView.dexItemFactory()),
- new NoInternalUtilityClasses(appView.dexItemFactory()),
- new SameParentClass()
+ new SameParentClass(),
+ new RespectPackageBoundaries(appView)
// TODO: add policies
);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
index 482ade5..b0e8d13 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
@@ -124,24 +124,40 @@
/** Bidirectional mapping from one method to another. */
public Builder moveMethod(DexMethod from, DexMethod to) {
+ if (from == to) {
+ return this;
+ }
+
mapMethod(from, to);
recordOriginalSignature(from, to);
return this;
}
public Builder recordOriginalSignature(DexMethod from, DexMethod to) {
+ if (from == to) {
+ return this;
+ }
+
originalMethodSignatures.forcePut(to, originalMethodSignatures.getOrDefault(from, from));
return this;
}
/** Unidirectional mapping from one method to another. */
public Builder recordExtraOriginalSignature(DexMethod from, DexMethod to) {
+ if (from == to) {
+ return this;
+ }
+
extraOriginalMethodSignatures.put(to, extraOriginalMethodSignatures.getOrDefault(from, from));
return this;
}
/** Unidirectional mapping from one method to another. */
public Builder mapMethod(DexMethod from, DexMethod to) {
+ if (from == to) {
+ return this;
+ }
+
for (DexMethod existingFrom :
completeInverseMethodMap.getOrDefault(from, Collections.emptySet())) {
methodMap.put(existingFrom, to);
@@ -151,8 +167,10 @@
.getOrDefault(existingFrom, Collections.emptySet())
.isEmpty();
}
+
methodMap.put(from, to);
completeInverseMethodMap.computeIfAbsent(to, ignore -> new HashSet<>()).add(from);
+
return this;
}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
index 1ce2ee4..5c67423 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.horizontalclassmerging;
import com.android.tools.r8.graph.DexProgramClass;
+import java.util.ArrayList;
import java.util.Collection;
public abstract class MultiClassPolicy extends Policy {
@@ -13,6 +14,7 @@
* Remove all groups containing no or only a single class, as there is no point in merging these.
*/
protected void removeTrivialGroups(Collection<Collection<DexProgramClass>> groups) {
+ assert !(groups instanceof ArrayList);
groups.removeIf(group -> group.size() < 2);
}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/SimplePolicyExecutor.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/SimplePolicyExecutor.java
index 9ec4e5f..322958f 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/SimplePolicyExecutor.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/SimplePolicyExecutor.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.graph.DexProgramClass;
import java.util.Collection;
import java.util.Iterator;
+import java.util.LinkedList;
import java.util.stream.Collectors;
/**
@@ -20,18 +21,12 @@
}
// TODO(b/165506334): if performing mutable operation ensure that linked lists are used
- private Collection<Collection<DexProgramClass>> applySingleClassPolicy(
- SingleClassPolicy policy, Collection<Collection<DexProgramClass>> groups) {
+ private LinkedList<Collection<DexProgramClass>> applySingleClassPolicy(
+ SingleClassPolicy policy, LinkedList<Collection<DexProgramClass>> groups) {
Iterator<Collection<DexProgramClass>> i = groups.iterator();
while (i.hasNext()) {
Collection<DexProgramClass> group = i.next();
- Iterator<DexProgramClass> j = group.iterator();
- while (j.hasNext()) {
- DexProgramClass clazz = j.next();
- if (!policy.canMerge(clazz)) {
- j.remove();
- }
- }
+ group.removeIf(clazz -> !policy.canMerge(clazz));
if (group.size() < 2) {
i.remove();
}
@@ -39,28 +34,36 @@
return groups;
}
- private Collection<Collection<DexProgramClass>> applyMultiClassPolicy(
- MultiClassPolicy policy, Collection<Collection<DexProgramClass>> groups) {
+ private LinkedList<Collection<DexProgramClass>> applyMultiClassPolicy(
+ MultiClassPolicy policy, LinkedList<Collection<DexProgramClass>> groups) {
// For each group apply the multi class policy and add all the new groups together.
return groups.stream()
.flatMap(group -> policy.apply(group).stream())
- .collect(Collectors.toList());
+ .collect(Collectors.toCollection(LinkedList::new));
}
@Override
public Collection<Collection<DexProgramClass>> run(
- Collection<Collection<DexProgramClass>> groups) {
+ Collection<Collection<DexProgramClass>> inputGroups) {
+ LinkedList<Collection<DexProgramClass>> linkedGroups;
+
+ if (inputGroups instanceof LinkedList) {
+ linkedGroups = (LinkedList<Collection<DexProgramClass>>) inputGroups;
+ } else {
+ linkedGroups = new LinkedList<>(inputGroups);
+ }
+
for (Policy policy : policies) {
if (policy instanceof SingleClassPolicy) {
- groups = applySingleClassPolicy((SingleClassPolicy) policy, groups);
+ linkedGroups = applySingleClassPolicy((SingleClassPolicy) policy, linkedGroups);
} else if (policy instanceof MultiClassPolicy) {
- groups = applyMultiClassPolicy((MultiClassPolicy) policy, groups);
+ linkedGroups = applyMultiClassPolicy((MultiClassPolicy) policy, linkedGroups);
}
// Any policy should not return any trivial groups.
- assert groups.stream().allMatch(group -> group.size() >= 2);
+ assert linkedGroups.stream().allMatch(group -> group.size() >= 2);
}
- return groups;
+ return linkedGroups;
}
}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoAnnotations.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoAnnotations.java
new file mode 100644
index 0000000..f96a787
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoAnnotations.java
@@ -0,0 +1,15 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+public class NoAnnotations extends SingleClassPolicy {
+ @Override
+ public boolean canMerge(DexProgramClass program) {
+ return !program.hasClassOrMemberAnnotations();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java
new file mode 100644
index 0000000..ddb2aef
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java
@@ -0,0 +1,16 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+public class NoInnerClasses extends SingleClassPolicy {
+
+ @Override
+ public boolean canMerge(DexProgramClass program) {
+ return program.getInnerClasses().isEmpty();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java
deleted file mode 100644
index 2887849..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java
+++ /dev/null
@@ -1,25 +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.horizontalclassmerging.policies;
-
-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.horizontalclassmerging.SingleClassPolicy;
-import java.util.Collections;
-import java.util.Set;
-
-public class NoInternalUtilityClasses extends SingleClassPolicy {
- private final Set<DexType> internalUtilityClasses;
-
- public NoInternalUtilityClasses(DexItemFactory dexItemFactory) {
- this.internalUtilityClasses = Collections.singleton(dexItemFactory.enumUnboxingUtilityType);
- }
-
- @Override
- public boolean canMerge(DexProgramClass program) {
- return !internalUtilityClasses.contains(program.type);
- }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKeepRules.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKeepRules.java
new file mode 100644
index 0000000..6181c41
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKeepRules.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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.Iterables;
+
+public class NoKeepRules extends SingleClassPolicy {
+ private final AppView<AppInfoWithLiveness> appView;
+
+ public NoKeepRules(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
+
+ @Override
+ public boolean canMerge(DexProgramClass program) {
+ DexType type = program.getType();
+ boolean anyPinned =
+ appView.appInfo().isPinned(type)
+ || Iterables.any(
+ program.members(), member -> appView.appInfo().isPinned(member.toReference()));
+ return !anyPinned;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotMatchedByNoHorizontalClassMerging.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotMatchedByNoHorizontalClassMerging.java
new file mode 100644
index 0000000..fbd17f3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotMatchedByNoHorizontalClassMerging.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Set;
+
+public class NotMatchedByNoHorizontalClassMerging extends SingleClassPolicy {
+ private final Set<DexType> neverMergeClassHorizontally;
+
+ public NotMatchedByNoHorizontalClassMerging(AppView<AppInfoWithLiveness> appView) {
+ neverMergeClassHorizontally = appView.appInfo().getNoHorizontalClassMergingSet();
+ }
+
+ @Override
+ public boolean canMerge(DexProgramClass program) {
+ return !neverMergeClassHorizontally.contains(program.toReference());
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java
new file mode 100644
index 0000000..4b112b8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMember;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.VerticalClassMerger.IllegalAccessDetector;
+import com.android.tools.r8.utils.TraversalContinuation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+public class RespectPackageBoundaries extends MultiClassPolicy {
+ private final AppView<AppInfoWithLiveness> appView;
+
+ public RespectPackageBoundaries(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
+
+ boolean shouldRestrictMergingAcrossPackageBoundary(DexProgramClass clazz) {
+ // Check that the class is public, otherwise it is package private.
+ if (!clazz.isPublic()) {
+ return true;
+ }
+
+ // If any members are package private or protected, then their access depends on the package.
+ for (DexEncodedMember<?, ?> member : clazz.members()) {
+ if (member.getAccessFlags().isPackagePrivateOrProtected()) {
+ return true;
+ }
+ }
+
+ // Check that all accesses from [clazz] to classes or members from the current package of
+ // [clazz] will continue to work. This is guaranteed if the methods of [clazz] do not access
+ // any private or protected classes or members from the current package of [clazz].
+ IllegalAccessDetector registry = new IllegalAccessDetector(appView, clazz);
+ TraversalContinuation result =
+ clazz.traverseProgramMethods(
+ method -> {
+ registry.setContext(method);
+ method.registerCodeReferences(registry);
+ if (registry.foundIllegalAccess()) {
+ return TraversalContinuation.BREAK;
+ }
+ return TraversalContinuation.CONTINUE;
+ });
+ return result.shouldBreak();
+ }
+
+ /** Sort unrestricted classes into restricted classes if they are in the same package. */
+ void tryFindRestrictedPackage(
+ LinkedList<DexProgramClass> unrestrictedClasses,
+ Map<String, Collection<DexProgramClass>> restrictedClasses) {
+ Iterator<DexProgramClass> i = unrestrictedClasses.iterator();
+ while (i.hasNext()) {
+ DexProgramClass clazz = i.next();
+ Collection<DexProgramClass> restrictedPackage =
+ restrictedClasses.get(clazz.type.getPackageDescriptor());
+ if (restrictedPackage != null) {
+ restrictedPackage.add(clazz);
+ i.remove();
+ }
+ }
+ }
+
+ @Override
+ public Collection<Collection<DexProgramClass>> apply(Collection<DexProgramClass> group) {
+ Map<String, Collection<DexProgramClass>> restrictedClasses = new LinkedHashMap<>();
+ LinkedList<DexProgramClass> unrestrictedClasses = new LinkedList<>();
+
+ // Sort all restricted classes into packages.
+ for (DexProgramClass clazz : group) {
+ if (shouldRestrictMergingAcrossPackageBoundary(clazz)) {
+ restrictedClasses
+ .computeIfAbsent(clazz.type.getPackageDescriptor(), ignore -> new ArrayList<>())
+ .add(clazz);
+ } else {
+ unrestrictedClasses.add(clazz);
+ }
+ }
+
+ tryFindRestrictedPackage(unrestrictedClasses, restrictedClasses);
+ removeTrivialGroups(restrictedClasses.values());
+
+ // TODO(b/166577694): Add the unrestricted classes to restricted groups, but ensure they aren't
+ // the merge target.
+ Collection<Collection<DexProgramClass>> groups = new ArrayList<>(restrictedClasses.size() + 1);
+ if (unrestrictedClasses.size() > 1) {
+ groups.add(unrestrictedClasses);
+ }
+ groups.addAll(restrictedClasses.values());
+ return groups;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
index 8d33495..1e93d1b 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
@@ -107,7 +107,10 @@
private void enqueueMethodsForReprocessing(
AppInfoWithLiveness appInfo, ExecutorService executorService) throws ExecutionException {
ThreadUtils.processItems(appInfo.classes(), this::processClass, executorService);
- ThreadUtils.processItems(appInfo.synthesizedClasses(), this::processClass, executorService);
+ ThreadUtils.processItems(
+ appInfo.getSyntheticItems().getPendingSyntheticClasses(),
+ this::processClass,
+ executorService);
postMethodProcessorBuilder.put(methodsToReprocess);
}
@@ -145,7 +148,8 @@
private static boolean verifyNoConstantFieldsOnSynthesizedClasses(
AppView<AppInfoWithLiveness> appView) {
- for (DexProgramClass clazz : appView.appInfo().synthesizedClasses()) {
+ for (DexProgramClass clazz :
+ appView.appInfo().getSyntheticItems().getPendingSyntheticClasses()) {
for (DexEncodedField field : clazz.fields()) {
assert field.getOptimizationInfo().getAbstractValue().isUnknown();
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedMessageLiteBuilderShrinker.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedMessageLiteBuilderShrinker.java
index 96cdb99..c374875 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedMessageLiteBuilderShrinker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedMessageLiteBuilderShrinker.java
@@ -264,11 +264,19 @@
AppView<? extends AppInfoWithClassHierarchy> appView,
SubtypingInfo subtypingInfo,
PredicateSet<DexType> alwaysClassInline,
- Set<DexType> neverMerge,
+ Set<DexType> neverMergeClassVertically,
+ Set<DexType> neverMergeClassHorizontally,
+ Set<DexType> neverMergeStaticClassHorizontally,
Set<DexMethod> alwaysInline,
Set<DexMethod> bypassClinitforInlining) {
new RootSetExtension(
- appView, alwaysClassInline, neverMerge, alwaysInline, bypassClinitforInlining)
+ appView,
+ alwaysClassInline,
+ neverMergeClassVertically,
+ neverMergeClassHorizontally,
+ neverMergeStaticClassHorizontally,
+ alwaysInline,
+ bypassClinitforInlining)
.extend(subtypingInfo);
}
@@ -383,7 +391,9 @@
private final ProtoReferences references;
private final PredicateSet<DexType> alwaysClassInline;
- private final Set<DexType> neverMerge;
+ private final Set<DexType> neverMergeClassVertically;
+ private final Set<DexType> neverMergeClassHorizontally;
+ private final Set<DexType> neverMergeStaticClassHorizontally;
private final Set<DexMethod> alwaysInline;
private final Set<DexMethod> bypassClinitforInlining;
@@ -391,13 +401,17 @@
RootSetExtension(
AppView<? extends AppInfoWithClassHierarchy> appView,
PredicateSet<DexType> alwaysClassInline,
- Set<DexType> neverMerge,
+ Set<DexType> neverMergeClassVertically,
+ Set<DexType> neverMergeClassHorizontally,
+ Set<DexType> neverMergeStaticClassHorizontally,
Set<DexMethod> alwaysInline,
Set<DexMethod> bypassClinitforInlining) {
this.appView = appView;
this.references = appView.protoShrinker().references;
this.alwaysClassInline = alwaysClassInline;
- this.neverMerge = neverMerge;
+ this.neverMergeClassVertically = neverMergeClassVertically;
+ this.neverMergeClassHorizontally = neverMergeClassHorizontally;
+ this.neverMergeStaticClassHorizontally = neverMergeStaticClassHorizontally;
this.alwaysInline = alwaysInline;
this.bypassClinitforInlining = bypassClinitforInlining;
}
@@ -451,14 +465,20 @@
// For consistency, never merge the GeneratedMessageLite builders. These will only have a
// unique subtype if the application has a single proto message, which mostly happens during
// testing.
- neverMerge.add(references.generatedMessageLiteBuilderType);
- neverMerge.add(references.generatedMessageLiteExtendableBuilderType);
+ neverMergeClass(references.generatedMessageLiteBuilderType);
+ neverMergeClass(references.generatedMessageLiteExtendableBuilderType);
}
private void neverMergeMessageLite() {
// MessageLite is used in several signatures that we use for recognizing methods, so don't
// allow it to me merged.
- neverMerge.add(references.messageLiteType);
+ neverMergeClass(references.messageLiteType);
+ }
+
+ private void neverMergeClass(DexType type) {
+ neverMergeClassVertically.add(type);
+ neverMergeClassHorizontally.add(type);
+ neverMergeStaticClassHorizontally.add(type);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleConstClassValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleConstClassValue.java
index 7240424..8f4baa6 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleConstClassValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleConstClassValue.java
@@ -87,9 +87,7 @@
DexClass clazz = appView.definitionFor(type);
return clazz != null
&& clazz.isResolvable(appView)
- && AccessControl.isClassAccessible(
- clazz, context.getHolder(), appView.options().featureSplitConfiguration)
- .isTrue();
+ && AccessControl.isClassAccessible(clazz, context, appView).isTrue();
}
assert baseType.isPrimitiveType();
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/CheckCast.java b/src/main/java/com/android/tools/r8/ir/code/CheckCast.java
index 35767cc..7085e80 100644
--- a/src/main/java/com/android/tools/r8/ir/code/CheckCast.java
+++ b/src/main/java/com/android/tools/r8/ir/code/CheckCast.java
@@ -108,6 +108,7 @@
if (type.isPrimitiveType()) {
return true;
}
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
DexType baseType = type.toBaseType(appView.dexItemFactory());
if (baseType.isClassType()) {
DexClass definition = appView.definitionFor(baseType);
@@ -116,11 +117,11 @@
return true;
}
// Check that the class is accessible.
- if (AccessControl.isClassAccessible(definition, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(definition, context, appViewWithLiveness)
+ .isPossiblyFalse()) {
return true;
}
}
- AppView<? extends AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
TypeElement castType = TypeElement.fromDexType(type, definitelyNotNull(), appView);
if (object()
.getDynamicUpperBoundType(appViewWithLiveness)
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
index d28135d..86101ba 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
@@ -114,13 +114,16 @@
return true;
}
+ assert appView.appInfo().hasLiveness();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
DexClass clazz = appView.definitionFor(baseType);
// * Check that the class and its super types are present.
if (clazz == null || !clazz.isResolvable(appView)) {
return true;
}
// * Check that the class is accessible.
- if (AccessControl.isClassAccessible(clazz, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(clazz, context, appViewWithLiveness).isPossiblyFalse()) {
return true;
}
return false;
diff --git a/src/main/java/com/android/tools/r8/ir/code/InitClass.java b/src/main/java/com/android/tools/r8/ir/code/InitClass.java
index d24dce8..22e4c4e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InitClass.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InitClass.java
@@ -94,13 +94,17 @@
@Override
public boolean instructionInstanceCanThrow(AppView<?> appView, ProgramMethod context) {
+ // We only use InitClass instructions in R8.
+ assert appView.enableWholeProgramOptimizations();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
DexClass definition = appView.definitionFor(clazz);
// * Check that the class is present.
if (definition == null) {
return true;
}
// * Check that the class is accessible.
- if (AccessControl.isClassAccessible(definition, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(definition, context, appViewWithLiveness)
+ .isPossiblyFalse()) {
return true;
}
if (clazz.classInitializationMayHaveSideEffects(
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
index 314317e..063592f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.LongInterval;
import java.util.List;
@@ -133,6 +134,9 @@
return true;
}
+ assert appView.appInfo().hasLiveness();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
// Check if the type is guaranteed to be present.
DexClass clazz = appView.definitionFor(baseType);
if (clazz == null) {
@@ -145,7 +149,7 @@
}
// Check if the type is guaranteed to be accessible.
- if (AccessControl.isClassAccessible(clazz, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(clazz, context, appViewWithLiveness).isPossiblyFalse()) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
index 2783471..25a4b47 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.List;
public class InvokeNewArray extends Invoke {
@@ -160,6 +161,9 @@
return true;
}
+ assert appView.appInfo().hasLiveness();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
// Check if the type is guaranteed to be present.
DexClass clazz = appView.definitionFor(baseType);
if (clazz == null) {
@@ -173,7 +177,7 @@
}
// Check if the type is guaranteed to be accessible.
- if (AccessControl.isClassAccessible(clazz, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(clazz, context, appViewWithLiveness).isPossiblyFalse()) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
index 3b8fc7f..ff7a054 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
@@ -169,7 +169,8 @@
}
// Verify that the instruction does not lead to an IllegalAccessError.
- if (AccessControl.isClassAccessible(definition, context, appView).isPossiblyFalse()) {
+ if (AccessControl.isClassAccessible(definition, context, appViewWithLiveness)
+ .isPossiblyFalse()) {
return true;
}
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 5107d27..605f698 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
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.conversion;
-import static com.android.tools.r8.graph.DexAnnotation.readAnnotationSynthesizedClassMap;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor.ExcludeDexResources;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor.IncludeAllResources;
@@ -13,7 +12,6 @@
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.DexApplication;
import com.android.tools.r8.graph.DexApplication.Builder;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -90,7 +88,6 @@
import com.android.tools.r8.position.MethodPosition;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.LibraryMethodOverrideAnalysis;
-import com.android.tools.r8.shaking.MainDexClasses;
import com.android.tools.r8.shaking.MainDexTracingResult;
import com.android.tools.r8.utils.Action;
import com.android.tools.r8.utils.CfgPrinter;
@@ -105,22 +102,16 @@
import com.android.tools.r8.utils.collections.ProgramMethodSet;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.base.Suppliers;
-import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ListMultimap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
import java.util.Set;
-import java.util.TreeSet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
-import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
@@ -237,8 +228,8 @@
this.desugaredLibraryAPIConverter =
new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS);
this.backportedMethodRewriter =
- options.testing.forceLibBackportsInL8CfToCf
- ? new BackportedMethodRewriter(appView, this)
+ options.cfToCfDesugar || options.testing.forceLibBackportsInL8CfToCf
+ ? new BackportedMethodRewriter(appView)
: null;
this.twrCloseResourceRewriter = null;
this.lambdaMerger = null;
@@ -276,7 +267,7 @@
((options.desugarState == DesugarState.ON) && enableTwrCloseResourceDesugaring())
? new TwrCloseResourceRewriter(appView, this)
: null;
- this.backportedMethodRewriter = new BackportedMethodRewriter(appView, this);
+ this.backportedMethodRewriter = new BackportedMethodRewriter(appView);
this.desugaredLibraryRetargeter =
options.desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()
? null
@@ -445,10 +436,10 @@
}
}
- private void synthesizeJava8UtilityClass(
- Builder<?> builder, ExecutorService executorService) throws ExecutionException {
+ private void processSynthesizedJava8UtilityClasses(ExecutorService executorService)
+ throws ExecutionException {
if (backportedMethodRewriter != null) {
- backportedMethodRewriter.synthesizeUtilityClasses(builder, executorService);
+ backportedMethodRewriter.processSynthesizedClasses(this, executorService);
}
}
@@ -459,10 +450,10 @@
}
}
- private void synthesizeEnumUnboxingUtilityMethods(
- Builder<?> builder, ExecutorService executorService) throws ExecutionException {
+ private void synthesizeEnumUnboxingUtilityMethods(ExecutorService executorService)
+ throws ExecutionException {
if (enumUnboxer != null) {
- enumUnboxer.synthesizeUtilityMethods(builder, this, executorService);
+ enumUnboxer.synthesizeUtilityMethods(this, executorService);
}
}
@@ -489,96 +480,19 @@
synthesizeLambdaClasses(builder, executor);
desugarInterfaceMethods(builder, ExcludeDexResources, executor);
synthesizeTwrCloseResourceUtilityClass(builder, executor);
- synthesizeJava8UtilityClass(builder, executor);
+ processSynthesizedJava8UtilityClasses(executor);
synthesizeRetargetClass(builder, executor);
processCovariantReturnTypeAnnotations(builder);
generateDesugaredLibraryAPIWrappers(builder, executor);
- handleSynthesizedClassMapping(appView, builder);
timing.end();
DexApplication app = builder.build();
appView.setAppInfo(
new AppInfo(
- app,
- appView.appInfo().getMainDexClasses(),
- appView.appInfo().getSyntheticItems().commit(app)));
- }
-
- private void handleSynthesizedClassMapping(AppView<?> appView, Builder<?> builder) {
- if (options.intermediate) {
- updateSynthesizedClassMapping(builder);
- }
-
- updateMainDexListWithSynthesizedClassMap(appView, builder);
-
- if (!options.intermediate) {
- clearSynthesizedClassMapping(builder);
- }
- }
-
- private void updateMainDexListWithSynthesizedClassMap(AppView<?> appView, Builder<?> builder) {
- MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
- if (mainDexClasses.isEmpty()) {
- return;
- }
- Map<DexType, DexProgramClass> programClasses =
- builder.getProgramClasses().stream()
- .collect(Collectors.toMap(programClass -> programClass.type, Function.identity()));
- List<DexProgramClass> newMainDexClasses = new ArrayList<>();
- mainDexClasses.forEach(
- mainDexClass -> {
- DexProgramClass definition = programClasses.get(mainDexClass);
- if (definition == null) {
- return;
- }
- Iterable<DexType> syntheticTypes =
- readAnnotationSynthesizedClassMap(definition, appView.dexItemFactory());
- for (DexType syntheticType : syntheticTypes) {
- DexProgramClass syntheticClass = programClasses.get(syntheticType);
- if (syntheticClass != null) {
- newMainDexClasses.add(syntheticClass);
- }
- }
- });
- mainDexClasses.addAll(newMainDexClasses);
- }
-
- private void clearSynthesizedClassMapping(Builder<?> builder) {
- for (DexProgramClass clazz : builder.getProgramClasses()) {
- clazz.setAnnotations(
- clazz.annotations().getWithout(builder.dexItemFactory.annotationSynthesizedClassMap));
- }
- }
-
- private void updateSynthesizedClassMapping(Builder<?> builder) {
- ListMultimap<DexProgramClass, DexProgramClass> originalToSynthesized =
- ArrayListMultimap.create();
- for (DexProgramClass synthesized : builder.getSynthesizedClasses()) {
- for (DexProgramClass original : synthesized.getSynthesizedFrom()) {
- originalToSynthesized.put(original, synthesized);
- }
- }
-
- for (Map.Entry<DexProgramClass, Collection<DexProgramClass>> entry :
- originalToSynthesized.asMap().entrySet()) {
- DexProgramClass original = entry.getKey();
- // Use a tree set to make sure that we have an ordering on the types.
- // These types are put in an array in annotations in the output and we
- // need a consistent ordering on them.
- TreeSet<DexType> synthesized = new TreeSet<>(DexType::slowCompareTo);
- entry.getValue()
- .stream()
- .map(dexProgramClass -> dexProgramClass.type)
- .forEach(synthesized::add);
- synthesized.addAll(readAnnotationSynthesizedClassMap(original, builder.dexItemFactory));
-
- DexAnnotation updatedAnnotation =
- DexAnnotation.createAnnotationSynthesizedClassMap(synthesized, builder.dexItemFactory);
-
- original.setAnnotations(original.annotations().getWithAddedOrReplaced(updatedAnnotation));
- }
+ appView.appInfo().getSyntheticItems().commit(app),
+ appView.appInfo().getMainDexClasses()));
}
private void convertMethods(DexProgramClass clazz) {
@@ -675,16 +589,9 @@
executorService);
}
- public DexApplication optimize() throws ExecutionException {
- ExecutorService executor = Executors.newSingleThreadExecutor();
- try {
- return optimize(executor);
- } finally {
- executor.shutdown();
- }
- }
-
- public DexApplication optimize(ExecutorService executorService) throws ExecutionException {
+ public DexApplication optimize(
+ AppView<AppInfoWithLiveness> appView, ExecutorService executorService)
+ throws ExecutionException {
DexApplication application = appView.appInfo().app();
computeReachabilitySensitivity(application);
@@ -804,10 +711,9 @@
printPhase("Utility classes synthesis");
synthesizeTwrCloseResourceUtilityClass(builder, executorService);
- synthesizeJava8UtilityClass(builder, executorService);
+ processSynthesizedJava8UtilityClasses(executorService);
synthesizeRetargetClass(builder, executorService);
- handleSynthesizedClassMapping(appView, builder);
- synthesizeEnumUnboxingUtilityMethods(builder, executorService);
+ synthesizeEnumUnboxingUtilityMethods(executorService);
printPhase("Lambda merging finalization");
// TODO(b/127694949): Adapt to PostOptimization.
@@ -885,14 +791,20 @@
// Assure that no more optimization feedback left after post processing.
assert feedback.noUpdatesLeft();
-
- // Check if what we've added to the application builder as synthesized classes are same as
- // what we've added and used through AppInfo.
- assert appView.appInfo().synthesizedClasses().containsAll(builder.getSynthesizedClasses())
- && builder.getSynthesizedClasses().containsAll(appView.appInfo().synthesizedClasses());
+ assert checkLegacySyntheticsAreInBuilder(appView, builder);
return builder.build();
}
+ private boolean checkLegacySyntheticsAreInBuilder(
+ AppView<AppInfoWithLiveness> appView, Builder<?> builder) {
+ Collection<DexProgramClass> inAppInfo =
+ appView.appInfo().getSyntheticItems().getLegacyPendingClasses();
+ Collection<DexProgramClass> inBuilder = builder.getSynthesizedClasses();
+ assert inAppInfo.containsAll(inBuilder);
+ assert inBuilder.containsAll(inAppInfo);
+ return true;
+ }
+
private void waveStart(ProgramMethodSet wave) {
onWaveDoneActions = Collections.synchronizedList(new ArrayList<>());
}
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 5c08f1f..8cc0ffa 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,27 +7,17 @@
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.AppView;
-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.DexApplication;
-import com.android.tools.r8.graph.DexApplication.Builder;
-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.DexString;
import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
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.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -45,7 +35,6 @@
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.origin.SynthesizedOrigin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.InternalOptions;
@@ -54,13 +43,13 @@
import com.google.common.collect.Sets;
import java.io.IOException;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Queue;
import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.function.Consumer;
@@ -72,18 +61,13 @@
public static final String UTILITY_CLASS_NAME_PREFIX = "$r8$backportedMethods$utility";
private final AppView<?> appView;
- private final IRConverter converter;
- private final DexItemFactory factory;
private final RewritableMethods rewritableMethods;
private final boolean enabled;
- private final Set<DexType> holders = Sets.newConcurrentHashSet();
- private final Map<DexMethod, MethodProvider> methodProviders = new ConcurrentHashMap<>();
+ private final Queue<ProgramMethod> synthesizedMethods = new ConcurrentLinkedQueue<>();
- public BackportedMethodRewriter(AppView<?> appView, IRConverter converter) {
+ public BackportedMethodRewriter(AppView<?> appView) {
this.appView = appView;
- this.converter = converter;
- this.factory = appView.dexItemFactory();
this.rewritableMethods = new RewritableMethods(appView.options(), appView);
// Disable rewriting if there are no methods to rewrite or if the API level is higher than
// the highest known API level when the compiler is built. This ensures that when this is used
@@ -128,7 +112,6 @@
if (!enabled) {
return; // Nothing to do!
}
-
Set<Value> affectedValues = Sets.newIdentityHashSet();
InstructionListIterator iterator = code.instructionListIterator();
while (iterator.hasNext()) {
@@ -143,17 +126,11 @@
continue;
}
- MethodProvider provider = getMethodProviderOrNull(invoke.getInvokedMethod());
- if (provider == null) {
- continue;
- }
-
- provider.rewriteInvoke(invoke, iterator, code, appView, affectedValues);
-
- if (provider.requiresGenerationOfCode()) {
- DexMethod newMethod = provider.provideMethod(appView);
- methodProviders.putIfAbsent(newMethod, provider);
- holders.add(code.method().holder());
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ MethodProvider provider = getMethodProviderOrNull(invokedMethod);
+ if (provider != null) {
+ provider.rewriteInvoke(
+ invoke, iterator, code, appView, affectedValues, synthesizedMethods::add);
}
}
if (!affectedValues.isEmpty()) {
@@ -161,125 +138,15 @@
}
}
- private Collection<DexProgramClass> findSynthesizedFrom(Builder<?> builder, DexType holder) {
- for (DexProgramClass synthesizedClass : builder.getSynthesizedClasses()) {
- if (holder == synthesizedClass.getType()) {
- return synthesizedClass.getSynthesizedFrom();
- }
- }
- return null;
- }
-
- public static boolean hasRewrittenMethodPrefix(DexType clazz) {
- return clazz.descriptor.toString().contains(UTILITY_CLASS_NAME_PREFIX);
- }
-
- public void synthesizeUtilityClasses(Builder<?> builder, ExecutorService executorService)
+ public void processSynthesizedClasses(IRConverter converter, ExecutorService executor)
throws ExecutionException {
- if (!enabled) {
- return;
- }
- if (holders.isEmpty()) {
- return;
- }
- // Compute referencing classes ignoring references in-between utility classes.
- Set<DexProgramClass> referencingClasses = Sets.newConcurrentHashSet();
- for (DexType holder : holders) {
- DexClass definitionFor = appView.definitionFor(holder);
- if (definitionFor == null) {
- Collection<DexProgramClass> synthesizedFrom = findSynthesizedFrom(builder, holder);
- assert synthesizedFrom != null;
- referencingClasses.addAll(synthesizedFrom);
- } else {
- referencingClasses.add(definitionFor.asProgramClass());
+ while (!synthesizedMethods.isEmpty()) {
+ List<ProgramMethod> methods = new ArrayList<>(synthesizedMethods);
+ synthesizedMethods.clear();
+ for (ProgramMethod method : methods) {
+ converter.optimizeSynthesizedClass(method.getHolder(), executor);
}
}
-
- MethodAccessFlags flags =
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false);
- ClassAccessFlags classAccessFlags =
- ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
- // Generate the utility classes in a loop since utility classes can require the
- // the creation of other utility classes.
- // Function multiplyExact(long, int) calls multiplyExact(long, long) for example.
- while (!methodProviders.isEmpty()) {
- DexMethod method = methodProviders.keySet().iterator().next();
- MethodProvider provider = methodProviders.remove(method);
- assert provider.requiresGenerationOfCode();
- // The utility class could have been synthesized, e.g., running R8 then D8,
- // or if already processed in this while loop.
- if (appView.definitionFor(method.holder) != null) {
- continue;
- }
- Code code = provider.generateTemplateMethod(appView.options(), method);
- DexEncodedMethod dexEncodedMethod =
- new DexEncodedMethod(
- method,
- flags,
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- code,
- true);
- boolean addToMainDexClasses =
- appView.appInfo().getMainDexClasses().containsAnyOf(referencingClasses);
- DexProgramClass utilityClass =
- synthesizeClassWithUniqueMethod(
- builder,
- classAccessFlags,
- method.holder,
- dexEncodedMethod,
- "java8 methods utility class",
- addToMainDexClasses,
- appView);
- // The following may add elements to methodsProviders.
- converter.optimizeSynthesizedClass(utilityClass, executorService);
- }
- }
-
- static DexProgramClass synthesizeClassWithUniqueMethod(
- Builder<?> builder,
- ClassAccessFlags accessFlags,
- DexType type,
- DexEncodedMethod uniqueMethod,
- String origin,
- boolean addToMainDexClasses,
- AppView<?> appView) {
- DexItemFactory factory = appView.dexItemFactory();
- DexProgramClass newClass =
- new DexProgramClass(
- type,
- null,
- new SynthesizedOrigin(origin, BackportedMethodRewriter.class),
- accessFlags,
- factory.objectType,
- DexTypeList.empty(),
- null,
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- uniqueMethod.isStatic()
- ? new DexEncodedMethod[] {uniqueMethod}
- : DexEncodedMethod.EMPTY_ARRAY,
- uniqueMethod.isStatic()
- ? DexEncodedMethod.EMPTY_ARRAY
- : new DexEncodedMethod[] {uniqueMethod},
- factory.getSkipNameValidationForTesting(),
- getChecksumSupplier(uniqueMethod, appView));
- appView.appInfo().addSynthesizedClass(newClass, addToMainDexClasses);
- builder.addSynthesizedClass(newClass);
- return newClass;
- }
-
- private static ChecksumSupplier getChecksumSupplier(DexEncodedMethod method, AppView<?> appView) {
- if (!appView.options().encodeChecksums) {
- return DexProgramClass::invalidChecksumRequest;
- }
- return c -> method.method.hashCode();
}
private MethodProvider getMethodProviderOrNull(DexMethod method) {
@@ -1433,13 +1300,8 @@
InstructionListIterator iterator,
IRCode code,
AppView<?> appView,
- Set<Value> affectedValues);
-
- public abstract DexMethod provideMethod(AppView<?> appView);
-
- public abstract Code generateTemplateMethod(InternalOptions options, DexMethod method);
-
- public abstract boolean requiresGenerationOfCode();
+ Set<Value> affectedValues,
+ Consumer<ProgramMethod> registerSynthesizedMethod);
}
private static final class InvokeRewriter extends MethodProvider {
@@ -1457,32 +1319,17 @@
InstructionListIterator iterator,
IRCode code,
AppView<?> appView,
- Set<Value> affectedValues) {
+ Set<Value> affectedValues,
+ Consumer<ProgramMethod> registerSynthesizedMethod) {
rewriter.rewrite(invoke, iterator, appView.dexItemFactory(), affectedValues);
assert code.isConsistentSSA();
}
-
- @Override
- public boolean requiresGenerationOfCode() {
- return false;
- }
-
- @Override
- public DexMethod provideMethod(AppView<?> appView) {
- throw new Unreachable();
- }
-
- @Override
- public Code generateTemplateMethod(InternalOptions options, DexMethod method) {
- throw new Unreachable();
- }
}
private static class MethodGenerator extends MethodProvider {
private final TemplateMethodFactory factory;
private final String methodName;
- DexMethod generatedMethod;
MethodGenerator(DexMethod method, TemplateMethodFactory factory) {
this(method, factory, method.name.toString());
@@ -1500,44 +1347,39 @@
InstructionListIterator iterator,
IRCode code,
AppView<?> appView,
- Set<Value> affectedValues) {
+ Set<Value> affectedValues,
+ Consumer<ProgramMethod> registerSynthesizedMethod) {
+ ProgramMethod method =
+ appView
+ .getSyntheticItems()
+ .createMethod(
+ code.context().getHolder(),
+ appView.dexItemFactory(),
+ builder ->
+ builder
+ .setProto(getProto(appView.dexItemFactory()))
+ .setAccessFlags(
+ MethodAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC
+ | Constants.ACC_STATIC
+ | Constants.ACC_SYNTHETIC,
+ false))
+ .setCode(
+ methodSig -> generateTemplateMethod(appView.options(), methodSig)));
+
iterator.replaceCurrentInstruction(
- new InvokeStatic(provideMethod(appView), invoke.outValue(), invoke.inValues()));
+ new InvokeStatic(method.getReference(), invoke.outValue(), invoke.inValues()));
+
+ registerSynthesizedMethod.accept(method);
}
- @Override
- public DexMethod provideMethod(AppView<?> appView) {
- if (generatedMethod != null) {
- return generatedMethod;
- }
- DexItemFactory factory = appView.dexItemFactory();
- String unqualifiedName = method.holder.getName();
- // Avoid duplicate class names between core lib dex file and program dex files.
- String descriptor =
- "L"
- + appView.options().synthesizedClassPrefix
- + UTILITY_CLASS_NAME_PREFIX
- + '$'
- + unqualifiedName
- + '$'
- + method.proto.parameters.size()
- + '$'
- + methodName
- + ';';
- DexType type = factory.createType(descriptor);
- generatedMethod = factory.createMethod(type, method.proto, method.name);
- return generatedMethod;
+ public DexProto getProto(DexItemFactory itemFactory) {
+ return method.proto;
}
- @Override
public Code generateTemplateMethod(InternalOptions options, DexMethod method) {
return factory.create(options, method);
}
-
- @Override
- public boolean requiresGenerationOfCode() {
- return true;
- }
}
// Specific subclass to transform virtual methods into static desugared methods.
@@ -1554,16 +1396,8 @@
}
@Override
- public DexMethod provideMethod(AppView<?> appView) {
- if (generatedMethod != null) {
- return generatedMethod;
- }
- super.provideMethod(appView);
- assert generatedMethod != null;
- DexProto newProto = appView.dexItemFactory().prependTypeToProto(receiverType, method.proto);
- generatedMethod =
- appView.dexItemFactory().createMethod(generatedMethod.holder, newProto, method.name);
- return generatedMethod;
+ public DexProto getProto(DexItemFactory itemFactory) {
+ return itemFactory.prependTypeToProto(receiverType, super.getProto(itemFactory));
}
}
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 5ce5bb8..5280f61 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
@@ -9,15 +9,19 @@
import com.android.tools.r8.graph.ClassAccessFlags;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexApplication.Builder;
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.DexLibraryClass;
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.DexString;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.ResolutionResult;
@@ -27,6 +31,7 @@
import com.android.tools.r8.ir.code.InvokeMethod;
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.StringDiagnostic;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.collect.Maps;
@@ -85,6 +90,49 @@
appView.options().reporter.warning(warning);
}
+ private static void synthesizeClassWithUniqueMethod(
+ Builder<?> builder,
+ ClassAccessFlags accessFlags,
+ DexType type,
+ DexEncodedMethod uniqueMethod,
+ String origin,
+ AppView<?> appView) {
+ DexItemFactory factory = appView.dexItemFactory();
+ DexProgramClass newClass =
+ new DexProgramClass(
+ type,
+ null,
+ new SynthesizedOrigin(origin, BackportedMethodRewriter.class),
+ accessFlags,
+ factory.objectType,
+ DexTypeList.empty(),
+ null,
+ null,
+ Collections.emptyList(),
+ null,
+ Collections.emptyList(),
+ DexAnnotationSet.empty(),
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedField.EMPTY_ARRAY,
+ uniqueMethod.isStatic()
+ ? new DexEncodedMethod[] {uniqueMethod}
+ : DexEncodedMethod.EMPTY_ARRAY,
+ uniqueMethod.isStatic()
+ ? DexEncodedMethod.EMPTY_ARRAY
+ : new DexEncodedMethod[] {uniqueMethod},
+ factory.getSkipNameValidationForTesting(),
+ getChecksumSupplier(uniqueMethod, appView));
+ appView.appInfo().addSynthesizedClass(newClass, false);
+ builder.addSynthesizedClass(newClass);
+ }
+
+ private static ChecksumSupplier getChecksumSupplier(DexEncodedMethod method, AppView<?> appView) {
+ if (!appView.options().encodeChecksums) {
+ return DexProgramClass::invalidChecksumRequest;
+ }
+ return c -> method.method.hashCode();
+ }
+
// Used by the ListOfBackportedMethods utility.
void visit(Consumer<DexMethod> consumer) {
retargetLibraryMember.keySet().forEach(consumer);
@@ -363,25 +411,23 @@
DexType interfaceType = dispatchInterfaceTypeFor(emulatedDispatchMethod);
DexEncodedMethod itfMethod =
generateInterfaceDispatchMethod(emulatedDispatchMethod, interfaceType);
- BackportedMethodRewriter.synthesizeClassWithUniqueMethod(
+ synthesizeClassWithUniqueMethod(
builder,
itfAccessFlags,
interfaceType,
itfMethod,
"desugared library dispatch interface",
- false,
appView);
// Dispatch holder.
DexType holderType = dispatchHolderTypeFor(emulatedDispatchMethod);
DexEncodedMethod dispatchMethod =
generateHolderDispatchMethod(emulatedDispatchMethod, holderType, itfMethod.method);
- BackportedMethodRewriter.synthesizeClassWithUniqueMethod(
+ synthesizeClassWithUniqueMethod(
builder,
holderAccessFlags,
holderType,
dispatchMethod,
"desugared library dispatch class",
- false,
appView);
}
}
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 aa15050..7f697a9 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
@@ -239,11 +239,11 @@
if (instruction.isInvokeStatic()) {
InvokeStatic invokeStatic = instruction.asInvokeStatic();
DexMethod method = invokeStatic.getInvokedMethod();
- DexClass clazz = appInfo.definitionFor(method.holder);
- if (BackportedMethodRewriter.hasRewrittenMethodPrefix(method.holder)) {
+ if (appView.getSyntheticItems().isPendingSynthetic(method.holder)) {
// We did not create this code yet, but it will not require rewriting.
continue;
}
+ DexClass clazz = appInfo.definitionFor(method.holder);
if (clazz == null) {
// NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
// exception but we can not report it as error since it can also be the intended
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 104fc97..ecad620 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
@@ -617,7 +617,7 @@
encodedMethod.getCode(),
true);
newMethod.copyMetadata(encodedMethod);
- rewriter.originalMethodSignatures.put(callTarget, encodedMethod.method);
+ rewriter.lensBuilder.move(encodedMethod.method, callTarget);
DexEncodedMethod.setDebugInfoWithFakeThisParameter(
newMethod.getCode(), callTarget.getArity(), appView);
@@ -689,7 +689,7 @@
encodedMethod.getCode(),
true);
newMethod.copyMetadata(encodedMethod);
- rewriter.originalMethodSignatures.put(callTarget, encodedMethod.method);
+ rewriter.lensBuilder.move(encodedMethod.method, callTarget);
return newMethod;
});
return new ProgramMethod(implMethodHolder, replacement);
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 dd7889d..fad4980 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
@@ -7,11 +7,13 @@
import com.android.tools.r8.graph.AppView;
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;
import com.android.tools.r8.graph.DexMethod;
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.EnclosingMethodAttribute;
import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
import com.android.tools.r8.graph.ProgramMethod;
@@ -31,8 +33,6 @@
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.ArrayList;
@@ -63,7 +63,7 @@
final DexString instanceFieldName;
- final BiMap<DexMethod, DexMethod> originalMethodSignatures = HashBiMap.create();
+ final LambdaRewriterLens.Builder lensBuilder = LambdaRewriterLens.builder();
// 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
@@ -160,6 +160,7 @@
appView.appInfo().addSynthesizedClass(synthesizedClass, lambdaClass.addToMainDexList.get());
builder.addSynthesizedClass(synthesizedClass);
}
+ fixup();
optimizeSynthesizedClasses(converter, executorService);
}
@@ -345,34 +346,78 @@
return knownLambdaClasses;
}
- public NestedGraphLens buildMappingLens(AppView<?> appView) {
- if (originalMethodSignatures.isEmpty()) {
+ public NestedGraphLens fixup() {
+ LambdaRewriterLens lens = lensBuilder.build(appView.graphLens(), appView.dexItemFactory());
+ if (lens == null) {
return null;
}
- return new LambdaRewriterLens(
- originalMethodSignatures, appView.graphLens(), appView.dexItemFactory());
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ EnclosingMethodAttribute enclosingMethod = clazz.getEnclosingMethodAttribute();
+ if (enclosingMethod != null) {
+ DexMethod mappedEnclosingMethod = lens.lookupMethod(enclosingMethod.getEnclosingMethod());
+ if (mappedEnclosingMethod != null
+ && mappedEnclosingMethod != enclosingMethod.getEnclosingMethod()) {
+ clazz.setEnclosingMethodAttribute(new EnclosingMethodAttribute(mappedEnclosingMethod));
+ }
+ }
+ }
+ ;
+ // Return lens without method map (but still retaining originalMethodSignatures), as the
+ // generated lambdas classes are generated with the an invoke to the new method, so no
+ // code rewriting is required.
+ return lens.withoutMethodMap();
}
static class LambdaRewriterLens extends NestedGraphLens {
- public LambdaRewriterLens(
+ LambdaRewriterLens(
+ Map<DexType, DexType> typeMap,
+ Map<DexMethod, DexMethod> methodMap,
+ Map<DexField, DexField> fieldMap,
+ BiMap<DexField, DexField> originalFieldSignatures,
BiMap<DexMethod, DexMethod> originalMethodSignatures,
- GraphLens graphLens,
- DexItemFactory factory) {
+ GraphLens previousLens,
+ DexItemFactory dexItemFactory) {
super(
- ImmutableMap.of(),
- ImmutableMap.of(),
- ImmutableMap.of(),
- null,
+ typeMap,
+ methodMap,
+ fieldMap,
+ originalFieldSignatures,
originalMethodSignatures,
- graphLens,
- factory);
+ previousLens,
+ dexItemFactory);
}
@Override
protected boolean isLegitimateToHaveEmptyMappings() {
return true;
}
+
+ private LambdaRewriterLens withoutMethodMap() {
+ methodMap.clear();
+ return this;
+ }
+
+ public static LambdaRewriterLens.Builder builder() {
+ return new LambdaRewriterLens.Builder();
+ }
+
+ public static class Builder extends NestedGraphLens.Builder {
+ public LambdaRewriterLens build(GraphLens previousLens, DexItemFactory dexItemFactory) {
+ if (typeMap.isEmpty() && methodMap.isEmpty() && fieldMap.isEmpty()) {
+ return null;
+ }
+ assert typeMap.isEmpty();
+ assert fieldMap.isEmpty();
+ return new LambdaRewriterLens(
+ typeMap,
+ methodMap,
+ fieldMap,
+ originalFieldSignatures,
+ originalMethodSignatures,
+ previousLens,
+ dexItemFactory);
+ }
+ }
}
}
-
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 996b8d8..70efbeb 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
@@ -1302,6 +1302,9 @@
return;
}
+ assert appView.appInfo().hasLiveness();
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
if (!appView.options().testing.enableCheckCastAndInstanceOfRemoval) {
return;
}
@@ -1337,7 +1340,8 @@
if (current.isCheckCast()) {
boolean hasPhiUsers = current.outValue().hasPhiUsers();
RemoveCheckCastInstructionIfTrivialResult removeResult =
- removeCheckCastInstructionIfTrivial(current.asCheckCast(), it, code, affectedValues);
+ removeCheckCastInstructionIfTrivial(
+ appViewWithLiveness, current.asCheckCast(), it, code, affectedValues);
if (removeResult != RemoveCheckCastInstructionIfTrivialResult.NO_REMOVALS) {
assert removeResult == RemoveCheckCastInstructionIfTrivialResult.REMOVED_CAST_DO_NARROW;
needToRemoveTrivialPhis |= hasPhiUsers;
@@ -1346,7 +1350,8 @@
}
} else if (current.isInstanceOf()) {
boolean hasPhiUsers = current.outValue().hasPhiUsers();
- if (removeInstanceOfInstructionIfTrivial(current.asInstanceOf(), it, code)) {
+ if (removeInstanceOfInstructionIfTrivial(
+ appViewWithLiveness, current.asInstanceOf(), it, code)) {
needToRemoveTrivialPhis |= hasPhiUsers;
}
}
@@ -1368,7 +1373,11 @@
// Returns true if the given check-cast instruction was removed.
private RemoveCheckCastInstructionIfTrivialResult removeCheckCastInstructionIfTrivial(
- CheckCast checkCast, InstructionListIterator it, IRCode code, Set<Value> affectedValues) {
+ AppView<AppInfoWithLiveness> appViewWithLiveness,
+ CheckCast checkCast,
+ InstructionListIterator it,
+ IRCode code,
+ Set<Value> affectedValues) {
Value inValue = checkCast.object();
Value outValue = checkCast.outValue();
DexType castType = checkCast.getType();
@@ -1380,7 +1389,7 @@
if (baseCastType.isClassType()) {
DexClass baseCastClass = appView.definitionFor(baseCastType);
if (baseCastClass == null
- || AccessControl.isClassAccessible(baseCastClass, code.context(), appView)
+ || AccessControl.isClassAccessible(baseCastClass, code.context(), appViewWithLiveness)
.isPossiblyFalse()) {
return RemoveCheckCastInstructionIfTrivialResult.NO_REMOVALS;
}
@@ -1436,7 +1445,10 @@
// Returns true if the given instance-of instruction was removed.
private boolean removeInstanceOfInstructionIfTrivial(
- InstanceOf instanceOf, InstructionListIterator it, IRCode code) {
+ AppView<AppInfoWithLiveness> appViewWithLiveness,
+ InstanceOf instanceOf,
+ InstructionListIterator it,
+ IRCode code) {
ProgramMethod context = code.context();
// If the instance-of type is not accessible in the current context, we should not remove the
@@ -1445,7 +1457,8 @@
if (instanceOfBaseType.isClassType()) {
DexClass instanceOfClass = appView.definitionFor(instanceOfBaseType);
if (instanceOfClass == null
- || AccessControl.isClassAccessible(instanceOfClass, context, appView).isPossiblyFalse()) {
+ || AccessControl.isClassAccessible(instanceOfClass, context, appViewWithLiveness)
+ .isPossiblyFalse()) {
return false;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index cbb86df..7a5dce9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.ir.optimize.inliner.InlinerUtils.collectAllMonitorEnterValues;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.Code;
import com.android.tools.r8.graph.DexEncodedField;
@@ -151,17 +152,16 @@
return false;
}
- InternalOptions options = appView.options();
- if (options.featureSplitConfiguration != null
- && !options.featureSplitConfiguration.inSameFeatureOrBothInBase(singleTarget, method)) {
+ ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
+ if (!classToFeatureSplitMap.isInSameFeatureOrBothInBase(singleTarget, method)) {
// Still allow inlining if we inline from the base into a feature.
- if (!options.featureSplitConfiguration.isInBase(singleTarget.getHolder())) {
+ if (!classToFeatureSplitMap.isInBase(singleTarget.getHolder())) {
whyAreYouNotInliningReporter.reportInliningAcrossFeatureSplit();
return false;
}
}
- Set<Reason> validInliningReasons = options.testing.validInliningReasons;
+ Set<Reason> validInliningReasons = appView.options().testing.validInliningReasons;
if (validInliningReasons != null && !validInliningReasons.contains(reason)) {
whyAreYouNotInliningReporter.reportInvalidInliningReason(reason, validInliningReasons);
return false;
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 611a249..a36f313 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
@@ -997,8 +997,8 @@
AccessControl.isMethodAccessible(
singleTarget.getDefinition(),
singleTarget.getHolder().asDexClass(),
- context.getHolder(),
- appView.withClassHierarchy().appInfo());
+ context,
+ appView);
if (!methodAccessible.isTrue()) {
continue;
}
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 7287edd..655ee2f 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
@@ -1284,8 +1284,7 @@
code -> {
ProgramMethod context = code.context();
assert !context.getDefinition().getCode().isOutlineCode();
- if (appView.options().featureSplitConfiguration != null
- && appView.options().featureSplitConfiguration.isInFeature(context.getHolder())) {
+ if (appView.appInfo().getClassToFeatureSplitMap().isInFeature(context.getHolder())) {
return;
}
for (BasicBlock block : code.blocks) {
@@ -1304,8 +1303,7 @@
public void identifyOutlineSites(IRCode code) {
ProgramMethod context = code.context();
assert !context.getDefinition().getCode().isOutlineCode();
- assert appView.options().featureSplitConfiguration == null
- || !appView.options().featureSplitConfiguration.isInFeature(context.getHolder());
+ assert !appView.appInfo().getClassToFeatureSplitMap().isInFeature(context.getHolder());
for (BasicBlock block : code.blocks) {
new OutlineSiteIdentifier(context, block).process();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
index fd270a4..f9f4d58 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
@@ -196,8 +196,7 @@
// Don't allow the instantiated class to be in a feature, if it is, we can get a
// NoClassDefFoundError from dalvik/art.
if (baseClazz.isProgramClass()
- && appView.options().featureSplitConfiguration != null
- && appView.options().featureSplitConfiguration.isInFeature(baseClazz.asProgramClass())) {
+ && appView.appInfo().getClassToFeatureSplitMap().isInFeature(baseClazz.asProgramClass())) {
return null;
}
// Make sure the (base) type is visible.
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 f1bcf3e..b1fcc81 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
@@ -74,9 +74,9 @@
private AtomicReference<DexProgramClass> synthesizedClass = new AtomicReference<>();
- private final AppView<? extends AppInfoWithLiveness> appView;
+ private final AppView<AppInfoWithLiveness> appView;
- public ServiceLoaderRewriter(AppView<? extends AppInfoWithLiveness> appView) {
+ public ServiceLoaderRewriter(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
}
@@ -133,7 +133,9 @@
}
// Check that we are not service loading anything from a feature into base.
- if (appView.appServices().hasServiceImplementationsInFeature(constClass.getValue())) {
+ if (appView
+ .appServices()
+ .hasServiceImplementationsInFeature(appView, constClass.getValue())) {
continue;
}
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 54b7f8d..d4adf44 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
@@ -4,18 +4,12 @@
package com.android.tools.r8.ir.optimize.enums;
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.AccessFlags;
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.DexApplication.Builder;
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClass.FieldSetter;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMember;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -23,22 +17,15 @@
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;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.DexValue.DexValueInt;
-import com.android.tools.r8.graph.DexValue.DexValueNull;
import com.android.tools.r8.graph.DirectMappedDexApplication;
import com.android.tools.r8.graph.EnumValueInfoMapCollection;
import com.android.tools.r8.graph.FieldResolutionResult;
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.graph.ProgramPackageCollection;
import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.graph.RewrittenPrototypeDescription;
-import com.android.tools.r8.graph.RewrittenPrototypeDescription.ArgumentInfoCollection;
-import com.android.tools.r8.graph.RewrittenPrototypeDescription.RewrittenTypeInfo;
import com.android.tools.r8.graph.UseRegistry;
import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
@@ -54,17 +41,14 @@
import com.android.tools.r8.ir.code.If;
import com.android.tools.r8.ir.code.InstanceGet;
import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.Invoke;
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.code.MemberType;
import com.android.tools.r8.ir.code.Opcodes;
import com.android.tools.r8.ir.code.Phi;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.conversion.CodeOptimization;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.conversion.PostMethodProcessor;
-import com.android.tools.r8.ir.conversion.PostOptimization;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldKnownData;
import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldMappingData;
@@ -74,24 +58,16 @@
import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedback.OptimizationInfoFixer;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
-import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.google.common.collect.BiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
-import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
import java.util.IdentityHashMap;
-import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
@@ -99,16 +75,15 @@
import java.util.concurrent.ExecutorService;
import java.util.function.Predicate;
-public class EnumUnboxer implements PostOptimization {
+public class EnumUnboxer {
private final AppView<AppInfoWithLiveness> appView;
private final DexItemFactory factory;
// Map the enum candidates with their dependencies, i.e., the methods to reprocess for the given
// enum if the optimization eventually decides to unbox it.
- private final Map<DexType, ProgramMethodSet> enumsUnboxingCandidates;
- private final Map<DexType, Set<DexField>> requiredEnumInstanceFieldData =
- new ConcurrentHashMap<>();
- private final Set<DexProgramClass> enumsToUnboxWithPackageRequirement = Sets.newIdentityHashSet();
+ private final EnumUnboxingCandidateInfoCollection enumUnboxingCandidatesInfo;
+ private final ProgramPackageCollection enumsToUnboxWithPackageRequirement =
+ ProgramPackageCollection.createEmpty();
private EnumUnboxingRewriter enumUnboxerRewriter;
@@ -126,19 +101,13 @@
debugLogs = null;
}
assert !appView.options().debug;
- enumsUnboxingCandidates = new EnumUnboxingCandidateAnalysis(appView, this).findCandidates();
- }
-
- private void requiredEnumInstanceFieldData(DexType enumType, DexField field) {
- requiredEnumInstanceFieldData
- .computeIfAbsent(enumType, ignored -> Sets.newConcurrentHashSet())
- .add(field);
+ enumUnboxingCandidatesInfo = new EnumUnboxingCandidateAnalysis(appView, this).findCandidates();
}
private void markEnumAsUnboxable(Reason reason, DexProgramClass enumClass) {
assert enumClass.isEnum();
reportFailure(enumClass.type, reason);
- enumsUnboxingCandidates.remove(enumClass.type);
+ enumUnboxingCandidatesInfo.removeCandidate(enumClass.type);
}
private DexProgramClass getEnumUnboxingCandidateOrNull(TypeElement lattice) {
@@ -156,10 +125,7 @@
}
private DexProgramClass getEnumUnboxingCandidateOrNull(DexType type) {
- if (!enumsUnboxingCandidates.containsKey(type)) {
- return null;
- }
- return appView.definitionForProgramType(type);
+ return enumUnboxingCandidatesInfo.getCandidateClassOrNull(type);
}
public void analyzeEnums(IRCode code) {
@@ -222,12 +188,7 @@
}
if (!eligibleEnums.isEmpty()) {
for (DexType eligibleEnum : eligibleEnums) {
- ProgramMethodSet dependencies = enumsUnboxingCandidates.get(eligibleEnum);
- // If dependencies is null, it means the enum is not eligible (It has been marked as
- // unboxable by this thread or another one), so we do not need to record dependencies.
- if (dependencies != null) {
- dependencies.add(code.context());
- }
+ enumUnboxingCandidatesInfo.addMethodDependency(eligibleEnum, code.context());
}
}
}
@@ -289,7 +250,7 @@
// - as a receiver for a name method, to allow unboxing of:
// MyEnum.class.getName();
DexType enumType = constClass.getValue();
- if (!enumsUnboxingCandidates.containsKey(enumType)) {
+ if (!enumUnboxingCandidatesInfo.isCandidate(enumType)) {
return;
}
if (constClass.outValue() == null) {
@@ -314,10 +275,15 @@
}
// The name data is required for the correct mapping from the enum name to the ordinal in the
// valueOf utility method.
- requiredEnumInstanceFieldData(enumType, factory.enumMembers.nameField);
+ addRequiredNameData(enumType);
eligibleEnums.add(enumType);
}
+ private void addRequiredNameData(DexType enumType) {
+ enumUnboxingCandidatesInfo.addRequiredEnumInstanceFieldData(
+ enumType, factory.enumMembers.nameField);
+ }
+
private boolean isUnboxableNameMethod(DexMethod method) {
return method == factory.classMethods.getName
|| method == factory.classMethods.getCanonicalName
@@ -330,7 +296,7 @@
InvokeMethod invokeMethod = use.asInvokeMethod();
DexMethod invokedMethod = invokeMethod.getInvokedMethod();
for (DexType paramType : invokedMethod.proto.parameters.values) {
- if (enumsUnboxingCandidates.containsKey(paramType)) {
+ if (enumUnboxingCandidatesInfo.isCandidate(paramType)) {
eligibleEnums.add(paramType);
}
}
@@ -342,12 +308,12 @@
}
} else if (use.isFieldPut()) {
DexType type = use.asFieldInstruction().getField().type;
- if (enumsUnboxingCandidates.containsKey(type)) {
+ if (enumUnboxingCandidatesInfo.isCandidate(type)) {
eligibleEnums.add(type);
}
} else if (use.isReturn()) {
DexType returnType = code.method().method.proto.returnType;
- if (enumsUnboxingCandidates.containsKey(returnType)) {
+ if (enumUnboxingCandidatesInfo.isCandidate(returnType)) {
eligibleEnums.add(returnType);
}
}
@@ -379,22 +345,41 @@
OptimizationFeedbackDelayed feedback)
throws ExecutionException {
EnumInstanceFieldDataMap enumInstanceFieldDataMap = finishAnalysis();
- // At this point the enumsToUnbox are no longer candidates, they will all be unboxed.
- if (enumsUnboxingCandidates.isEmpty()) {
+ // At this point the enum unboxing candidates are no longer candidates, they will all be
+ // unboxed. We extract the now immutable enums to unbox information and clear the candidate
+ // info.
+ if (enumUnboxingCandidatesInfo.isEmpty()) {
return;
}
- ImmutableSet<DexType> enumsToUnbox = ImmutableSet.copyOf(this.enumsUnboxingCandidates.keySet());
+ ImmutableSet<DexType> enumsToUnbox = enumUnboxingCandidatesInfo.candidates();
+ ImmutableSet<DexProgramClass> enumClassesToUnbox =
+ enumUnboxingCandidatesInfo.candidateClasses();
+ ProgramMethodSet dependencies = enumUnboxingCandidatesInfo.allMethodDependencies();
+ enumUnboxingCandidatesInfo.clear();
// Update keep info on any of the enum methods of the removed classes.
- updateKeepInfo(enumsToUnbox);
- enumUnboxerRewriter = new EnumUnboxingRewriter(appView, enumsToUnbox, enumInstanceFieldDataMap);
+ updateKeepInfo(enumClassesToUnbox);
DirectMappedDexApplication.Builder appBuilder = appView.appInfo().app().asDirect().builder();
- Map<DexType, DexType> newMethodLocation = synthesizeUnboxedEnumsMethodsLocations(appBuilder);
+ UnboxedEnumMemberRelocator relocator =
+ UnboxedEnumMemberRelocator.builder(appView)
+ .synthesizeEnumUnboxingUtilityClasses(
+ enumClassesToUnbox, enumsToUnboxWithPackageRequirement, appBuilder)
+ .build();
+ enumUnboxerRewriter =
+ new EnumUnboxingRewriter(appView, enumsToUnbox, enumInstanceFieldDataMap, relocator);
NestedGraphLens enumUnboxingLens =
- new TreeFixer(enumsToUnbox).fixupTypeReferences(newMethodLocation);
+ new EnumUnboxingTreeFixer(appView, enumsToUnbox, relocator, enumUnboxerRewriter)
+ .fixupTypeReferences();
appView.setUnboxedEnums(enumUnboxerRewriter.getEnumsToUnbox());
GraphLens previousLens = appView.graphLens();
appView.rewriteWithLensAndApplication(enumUnboxingLens, appBuilder.build());
- // Update optimization info.
+ updateOptimizationInfos(executorService, feedback);
+ postBuilder.put(dependencies);
+ postBuilder.rewrittenWithLens(appView, previousLens);
+ }
+
+ private void updateOptimizationInfos(
+ ExecutorService executorService, OptimizationFeedbackDelayed feedback)
+ throws ExecutionException {
feedback.fixupOptimizationInfos(
appView,
executorService,
@@ -426,88 +411,22 @@
}
}
});
- postBuilder.put(this);
- postBuilder.rewrittenWithLens(appView, previousLens);
}
- // Some enums may have methods which require to stay in the current package for accessibility,
- // in this case we create another class than the enum unboxing utility class to host these
- // methods.
- private Map<DexType, DexType> synthesizeUnboxedEnumsMethodsLocations(
- DirectMappedDexApplication.Builder appBuilder) {
- if (enumsToUnboxWithPackageRequirement.isEmpty()) {
- return Collections.emptyMap();
- }
- Map<DexType, DexType> newMethodLocationMap = new IdentityHashMap<>();
- Map<String, DexProgramClass> packageToClassMap = new HashMap<>();
- for (DexProgramClass toUnbox : enumsToUnboxWithPackageRequirement) {
- String packageDescriptor = toUnbox.getType().getPackageDescriptor();
- DexProgramClass syntheticClass = packageToClassMap.get(packageDescriptor);
- if (syntheticClass == null) {
- syntheticClass = synthesizeUtilityClassInPackage(packageDescriptor, appBuilder);
- packageToClassMap.put(packageDescriptor, syntheticClass);
- }
- if (appView.appInfo().getMainDexClasses().contains(toUnbox)) {
- appView.appInfo().getMainDexClasses().add(syntheticClass);
- }
- newMethodLocationMap.put(toUnbox.getType(), syntheticClass.getType());
- }
- enumsToUnboxWithPackageRequirement.clear();
- return newMethodLocationMap;
- }
-
- private DexProgramClass synthesizeUtilityClassInPackage(
- String packageDescriptor, DirectMappedDexApplication.Builder appBuilder) {
- DexType type =
- factory.createType(
- "L"
- + packageDescriptor
- + "/"
- + EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_CLASS_NAME
- + ";");
- if (type == factory.enumUnboxingUtilityType) {
- return appView.definitionFor(type).asProgramClass();
- }
- DexProgramClass syntheticClass =
- new DexProgramClass(
- type,
- null,
- new SynthesizedOrigin("enum unboxing", EnumUnboxer.class),
- ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC),
- factory.objectType,
- DexTypeList.empty(),
- null,
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- factory.getSkipNameValidationForTesting(),
- DexProgramClass::checksumFromType);
- appBuilder.addSynthesizedClass(syntheticClass);
- appView.appInfo().addSynthesizedClass(syntheticClass, false);
- return syntheticClass;
- }
-
- private void updateKeepInfo(Set<DexType> enumsToUnbox) {
+ private void updateKeepInfo(Set<DexProgramClass> enumsToUnbox) {
appView
.appInfo()
.getKeepInfo()
.mutate(
keepInfo -> {
- for (DexType type : enumsToUnbox) {
- DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(type));
- assert !keepInfo.getClassInfo(clazz).isPinned();
- clazz.forEachProgramMethod(
+ for (DexProgramClass enumToUnbox : enumsToUnbox) {
+ assert !keepInfo.getClassInfo(enumToUnbox).isPinned();
+ enumToUnbox.forEachProgramMethod(
method -> {
keepInfo.unsafeAllowMinificationOfMethod(method);
keepInfo.unsafeUnpinMethod(method);
});
- clazz.forEachProgramField(
+ enumToUnbox.forEachProgramField(
field -> {
keepInfo.unsafeAllowMinificationOfField(field);
keepInfo.unsafeUnpinField(field);
@@ -529,23 +448,19 @@
private EnumInstanceFieldDataMap analyzeFields() {
ImmutableMap.Builder<DexType, ImmutableMap<DexField, EnumInstanceFieldKnownData>> builder =
ImmutableMap.builder();
- requiredEnumInstanceFieldData.forEach(
- (enumType, fields) -> {
+ enumUnboxingCandidatesInfo.forEachCandidateAndRequiredInstanceFieldData(
+ (enumClass, fields) -> {
ImmutableMap.Builder<DexField, EnumInstanceFieldKnownData> typeBuilder =
ImmutableMap.builder();
- if (enumsUnboxingCandidates.containsKey(enumType)) {
- DexProgramClass enumClass = appView.definitionFor(enumType).asProgramClass();
- assert enumClass != null;
- for (DexField field : fields) {
- EnumInstanceFieldData enumInstanceFieldData = computeEnumFieldData(field, enumClass);
- if (enumInstanceFieldData.isUnknown()) {
- markEnumAsUnboxable(Reason.MISSING_INSTANCE_FIELD_DATA, enumClass);
- return;
- }
- typeBuilder.put(field, enumInstanceFieldData.asEnumFieldKnownData());
+ for (DexField field : fields) {
+ EnumInstanceFieldData enumInstanceFieldData = computeEnumFieldData(field, enumClass);
+ if (enumInstanceFieldData.isUnknown()) {
+ markEnumAsUnboxable(Reason.MISSING_INSTANCE_FIELD_DATA, enumClass);
+ return;
}
- builder.put(enumType, typeBuilder.build());
+ typeBuilder.put(field, enumInstanceFieldData.asEnumFieldKnownData());
}
+ builder.put(enumClass.type, typeBuilder.build());
});
return new EnumInstanceFieldDataMap(builder.build());
}
@@ -553,15 +468,15 @@
private void analyzeAccessibility() {
// Unboxing an enum will require to move its methods to a different class, which may impact
// accessibility. For a quick analysis we simply reuse the inliner analysis.
- for (DexType toUnbox : enumsUnboxingCandidates.keySet()) {
- DexProgramClass enumClass = appView.definitionFor(toUnbox).asProgramClass();
- Constraint classConstraint = analyzeAccessibilityInClass(enumClass);
- if (classConstraint == Constraint.NEVER) {
- markEnumAsUnboxable(Reason.ACCESSIBILITY, enumClass);
- } else if (classConstraint == Constraint.PACKAGE) {
- enumsToUnboxWithPackageRequirement.add(enumClass);
- }
- }
+ enumUnboxingCandidatesInfo.forEachCandidate(
+ enumClass -> {
+ Constraint classConstraint = analyzeAccessibilityInClass(enumClass);
+ if (classConstraint == Constraint.NEVER) {
+ markEnumAsUnboxable(Reason.ACCESSIBILITY, enumClass);
+ } else if (classConstraint == Constraint.PACKAGE) {
+ enumsToUnboxWithPackageRequirement.addProgramClass(enumClass);
+ }
+ });
}
private Constraint analyzeAccessibilityInClass(DexProgramClass enumClass) {
@@ -784,35 +699,33 @@
}
private void analyzeInitializers() {
- for (DexType toUnbox : enumsUnboxingCandidates.keySet()) {
- DexProgramClass enumClass = appView.definitionForProgramType(toUnbox);
- assert enumClass != null;
-
- boolean hasInstanceInitializer = false;
- for (DexEncodedMethod directMethod : enumClass.directMethods()) {
- if (directMethod.isInstanceInitializer()) {
- hasInstanceInitializer = true;
- if (directMethod
- .getOptimizationInfo()
- .getInstanceInitializerInfo()
- .mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
- markEnumAsUnboxable(Reason.INVALID_INIT, enumClass);
- break;
+ enumUnboxingCandidatesInfo.forEachCandidate(
+ enumClass -> {
+ boolean hasInstanceInitializer = false;
+ for (DexEncodedMethod directMethod : enumClass.directMethods()) {
+ if (directMethod.isInstanceInitializer()) {
+ hasInstanceInitializer = true;
+ if (directMethod
+ .getOptimizationInfo()
+ .getInstanceInitializerInfo()
+ .mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
+ markEnumAsUnboxable(Reason.INVALID_INIT, enumClass);
+ break;
+ }
+ }
}
- }
- }
- if (!hasInstanceInitializer) {
- // This case typically happens when a programmer uses EnumSet/EnumMap without using the
- // enum keep rules. The code is incorrect in this case (EnumSet/EnumMap won't work).
- // We bail out.
- markEnumAsUnboxable(Reason.NO_INIT, enumClass);
- continue;
- }
+ if (!hasInstanceInitializer) {
+ // This case typically happens when a programmer uses EnumSet/EnumMap without using the
+ // enum keep rules. The code is incorrect in this case (EnumSet/EnumMap won't work).
+ // We bail out.
+ markEnumAsUnboxable(Reason.NO_INIT, enumClass);
+ return;
+ }
- if (enumClass.classInitializationMayHaveSideEffects(appView)) {
- markEnumAsUnboxable(Reason.INVALID_CLINIT, enumClass);
- }
- }
+ if (enumClass.classInitializationMayHaveSideEffects(appView)) {
+ markEnumAsUnboxable(Reason.INVALID_CLINIT, enumClass);
+ }
+ });
}
private Reason instructionAllowEnumUnboxing(
@@ -834,7 +747,7 @@
return Reason.INVALID_INVOKE;
}
DexMethod singleTarget = encodedSingleTarget.method;
- DexClass dexClass = appView.definitionFor(singleTarget.holder);
+ DexClass dexClass = appView.definitionFor(singleTarget.holder, code.context());
if (dexClass == null) {
assert false;
return Reason.INVALID_INVOKE;
@@ -878,7 +791,7 @@
return Reason.ELIGIBLE;
}
if (singleTarget == factory.stringMembers.valueOf) {
- requiredEnumInstanceFieldData(enumClass.type, factory.enumMembers.nameField);
+ addRequiredNameData(enumClass.type);
return Reason.ELIGIBLE;
}
if (singleTarget == factory.objectMembers.getClass
@@ -900,14 +813,14 @@
} else if (singleTarget == factory.enumMembers.nameMethod
|| singleTarget == factory.enumMembers.toString) {
assert invokeMethod.asInvokeMethodWithReceiver().getReceiver() == enumValue;
- requiredEnumInstanceFieldData(enumClass.type, factory.enumMembers.nameField);
+ addRequiredNameData(enumClass.type);
return Reason.ELIGIBLE;
} else if (singleTarget == factory.enumMembers.ordinalMethod) {
return Reason.ELIGIBLE;
} else if (singleTarget == factory.enumMembers.hashCode) {
return Reason.ELIGIBLE;
} else if (singleTarget == factory.enumMembers.constructor) {
- // Enum constructor call is allowed only if first call of an enum initializer.
+ // Enum constructor call is allowed only if called from an enum initializer.
if (code.method().isInstanceInitializer() && code.method().holder() == enumClass.type) {
return Reason.ELIGIBLE;
}
@@ -924,7 +837,7 @@
if (field == null) {
return Reason.INVALID_FIELD_PUT;
}
- DexProgramClass dexClass = appView.definitionForProgramType(field.holder());
+ DexProgramClass dexClass = appView.programDefinitionFor(field.holder(), code.context());
if (dexClass == null) {
return Reason.INVALID_FIELD_PUT;
}
@@ -943,7 +856,7 @@
InstanceGet instanceGet = instruction.asInstanceGet();
assert instanceGet.getField().holder == enumClass.type;
DexField field = instanceGet.getField();
- requiredEnumInstanceFieldData(enumClass.type, field);
+ enumUnboxingCandidatesInfo.addRequiredEnumInstanceFieldData(enumClass.type, field);
return Reason.ELIGIBLE;
}
@@ -1112,12 +1025,13 @@
private void reportEnumsAnalysis() {
assert debugLogEnabled;
Reporter reporter = appView.options().reporter;
+ Set<DexType> candidates = enumUnboxingCandidatesInfo.candidates();
reporter.info(
new StringDiagnostic(
"Unboxed enums (Unboxing succeeded "
- + enumsUnboxingCandidates.size()
+ + candidates.size()
+ "): "
- + Arrays.toString(enumsUnboxingCandidates.keySet().toArray())));
+ + Arrays.toString(candidates.toArray())));
StringBuilder sb = new StringBuilder();
sb.append("Boxed enums (Unboxing failed ").append(debugLogs.size()).append("):\n");
for (DexType enumType : debugLogs.keySet()) {
@@ -1145,29 +1059,13 @@
return Sets.newIdentityHashSet();
}
- public void synthesizeUtilityMethods(
- Builder<?> builder, IRConverter converter, ExecutorService executorService)
+ public void synthesizeUtilityMethods(IRConverter converter, ExecutorService executorService)
throws ExecutionException {
if (enumUnboxerRewriter != null) {
- enumUnboxerRewriter.synthesizeEnumUnboxingUtilityMethods(builder, converter, executorService);
+ enumUnboxerRewriter.synthesizeEnumUnboxingUtilityMethods(converter, executorService);
}
}
- @Override
- public ProgramMethodSet methodsToRevisit() {
- ProgramMethodSet toReprocess = ProgramMethodSet.create();
- for (ProgramMethodSet methods : enumsUnboxingCandidates.values()) {
- toReprocess.addAll(methods);
- }
- return toReprocess;
- }
-
- @Override
- public Collection<CodeOptimization> codeOptimizationsForPostProcessing() {
- // Answers null so default optimization setup is performed.
- return null;
- }
-
public enum Reason {
ELIGIBLE,
ACCESSIBILITY,
@@ -1205,307 +1103,4 @@
ENUM_METHOD_CALLED_WITH_NULL_RECEIVER,
OTHER_UNSUPPORTED_INSTRUCTION;
}
-
- private class TreeFixer {
-
- private final Map<DexType, List<DexEncodedMethod>> unboxedEnumsMethods =
- new IdentityHashMap<>();
- private final EnumUnboxingLens.Builder lensBuilder = EnumUnboxingLens.builder();
- private final Set<DexType> enumsToUnbox;
-
- private TreeFixer(Set<DexType> enumsToUnbox) {
- this.enumsToUnbox = enumsToUnbox;
- }
-
- private NestedGraphLens fixupTypeReferences(Map<DexType, DexType> newMethodLocation) {
- assert enumUnboxerRewriter != null;
- // Fix all methods and fields using enums to unbox.
- for (DexProgramClass clazz : appView.appInfo().classes()) {
- if (enumsToUnbox.contains(clazz.type)) {
- // Clear the initializers and move the static methods to the new location.
- Set<DexEncodedMethod> methodsToRemove = Sets.newIdentityHashSet();
- clazz
- .methods()
- .forEach(
- m -> {
- if (m.isInitializer()) {
- clearEnumToUnboxMethod(m);
- } else {
- DexType newHolder =
- newMethodLocation.getOrDefault(
- clazz.type, factory.enumUnboxingUtilityType);
- List<DexEncodedMethod> movedMethods =
- unboxedEnumsMethods.computeIfAbsent(newHolder, k -> new ArrayList<>());
- movedMethods.add(fixupEncodedMethodToUtility(m, newHolder));
- methodsToRemove.add(m);
- }
- });
- clazz.getMethodCollection().removeMethods(methodsToRemove);
- } else {
- clazz.getMethodCollection().replaceMethods(this::fixupEncodedMethod);
- fixupFields(clazz.staticFields(), clazz::setStaticField);
- fixupFields(clazz.instanceFields(), clazz::setInstanceField);
- }
- }
- for (DexType toUnbox : enumsToUnbox) {
- lensBuilder.map(toUnbox, factory.intType);
- }
- DexProgramClass utilityClass =
- appView.definitionForProgramType(factory.enumUnboxingUtilityType);
- assert utilityClass != null : "Should have been synthesized upfront";
- unboxedEnumsMethods.forEach(
- (newHolderType, movedMethods) -> {
- DexProgramClass newHolderClass = appView.definitionFor(newHolderType).asProgramClass();
- newHolderClass.addDirectMethods(movedMethods);
- });
- return lensBuilder.build(factory, appView.graphLens(), enumsToUnbox);
- }
-
- private void clearEnumToUnboxMethod(DexEncodedMethod enumMethod) {
- // The compiler may have references to the enum methods, but such methods will be removed
- // and they cannot be reprocessed since their rewriting through the lensCodeRewriter/
- // enumUnboxerRewriter will generate invalid code.
- // To work around this problem we clear such methods, i.e., we replace the code object by
- // an empty throwing code object, so reprocessing won't take time and will be valid.
- enumMethod.setCode(enumMethod.buildEmptyThrowingCode(appView.options()), appView);
- }
-
- private DexEncodedMethod fixupEncodedMethodToUtility(
- DexEncodedMethod encodedMethod, DexType newHolder) {
- DexMethod method = encodedMethod.method;
- DexString newMethodName =
- factory.createString(
- enumUnboxerRewriter.compatibleName(method.holder)
- + "$"
- + (encodedMethod.isStatic() ? "s" : "v")
- + "$"
- + method.name.toString());
- DexProto proto =
- encodedMethod.isStatic() ? method.proto : factory.prependHolderToProto(method);
- DexMethod newMethod = factory.createMethod(newHolder, fixupProto(proto), newMethodName);
- assert appView.definitionFor(encodedMethod.holder()).lookupMethod(newMethod) == null;
- lensBuilder.move(method, encodedMethod.isStatic(), newMethod, true);
- encodedMethod.accessFlags.promoteToPublic();
- encodedMethod.accessFlags.promoteToStatic();
- encodedMethod.clearAnnotations();
- encodedMethod.clearParameterAnnotations();
- return encodedMethod.toTypeSubstitutedMethod(newMethod);
- }
-
- private DexEncodedMethod fixupEncodedMethod(DexEncodedMethod encodedMethod) {
- DexProto newProto = fixupProto(encodedMethod.proto());
- if (newProto == encodedMethod.proto()) {
- return encodedMethod;
- }
- assert !encodedMethod.isClassInitializer();
- // We add the $enumunboxing$ suffix to make sure we do not create a library override.
- String newMethodName =
- encodedMethod.getName().toString()
- + (encodedMethod.isNonPrivateVirtualMethod() ? "$enumunboxing$" : "");
- DexMethod newMethod = factory.createMethod(encodedMethod.holder(), newProto, newMethodName);
- newMethod = ensureUniqueMethod(encodedMethod, newMethod);
- int numberOfExtraNullParameters = newMethod.getArity() - encodedMethod.method.getArity();
- boolean isStatic = encodedMethod.isStatic();
- lensBuilder.move(
- encodedMethod.method, isStatic, newMethod, isStatic, numberOfExtraNullParameters);
- DexEncodedMethod newEncodedMethod = encodedMethod.toTypeSubstitutedMethod(newMethod);
- assert !encodedMethod.isLibraryMethodOverride().isTrue()
- : "Enum unboxing is changing the signature of a library override in a non unboxed class.";
- if (newEncodedMethod.isNonPrivateVirtualMethod()) {
- newEncodedMethod.setLibraryMethodOverride(OptionalBool.FALSE);
- }
- return newEncodedMethod;
- }
-
- private DexMethod ensureUniqueMethod(DexEncodedMethod encodedMethod, DexMethod newMethod) {
- DexClass holder = appView.definitionFor(encodedMethod.holder());
- assert holder != null;
- if (encodedMethod.isInstanceInitializer()) {
- while (holder.lookupMethod(newMethod) != null) {
- newMethod =
- factory.createMethod(
- newMethod.holder,
- factory.appendTypeToProto(newMethod.proto, factory.enumUnboxingUtilityType),
- newMethod.name);
- }
- } else {
- int index = 0;
- while (holder.lookupMethod(newMethod) != null) {
- newMethod =
- factory.createMethod(
- newMethod.holder,
- newMethod.proto,
- encodedMethod.getName().toString() + "$enumunboxing$" + index++);
- }
- }
- return newMethod;
- }
-
- private void fixupFields(List<DexEncodedField> fields, FieldSetter setter) {
- if (fields == null) {
- return;
- }
- for (int i = 0; i < fields.size(); i++) {
- DexEncodedField encodedField = fields.get(i);
- DexField field = encodedField.field;
- DexType newType = fixupType(field.type);
- if (newType != field.type) {
- DexField newField = factory.createField(field.holder, newType, field.name);
- lensBuilder.move(field, newField);
- DexEncodedField newEncodedField = encodedField.toTypeSubstitutedField(newField);
- setter.setField(i, newEncodedField);
- if (encodedField.isStatic() && encodedField.hasExplicitStaticValue()) {
- assert encodedField.getStaticValue() == DexValueNull.NULL;
- newEncodedField.setStaticValue(DexValueInt.DEFAULT);
- // TODO(b/150593449): Support conversion from DexValueEnum to DexValueInt.
- }
- }
- }
- }
-
- private DexProto fixupProto(DexProto proto) {
- DexType returnType = fixupType(proto.returnType);
- DexType[] arguments = fixupTypes(proto.parameters.values);
- return factory.createProto(returnType, arguments);
- }
-
- private DexType fixupType(DexType type) {
- if (type.isArrayType()) {
- DexType base = type.toBaseType(factory);
- DexType fixed = fixupType(base);
- if (base == fixed) {
- return type;
- }
- return type.replaceBaseType(fixed, factory);
- }
- if (type.isClassType() && enumsToUnbox.contains(type)) {
- DexType intType = factory.intType;
- lensBuilder.map(type, intType);
- return intType;
- }
- return type;
- }
-
- private DexType[] fixupTypes(DexType[] types) {
- DexType[] result = new DexType[types.length];
- for (int i = 0; i < result.length; i++) {
- result[i] = fixupType(types[i]);
- }
- return result;
- }
- }
-
- private static class EnumUnboxingLens extends NestedGraphLens {
-
- private final Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod;
- private final Set<DexType> unboxedEnums;
-
- EnumUnboxingLens(
- Map<DexType, DexType> typeMap,
- Map<DexMethod, DexMethod> methodMap,
- Map<DexField, DexField> fieldMap,
- BiMap<DexField, DexField> originalFieldSignatures,
- BiMap<DexMethod, DexMethod> originalMethodSignatures,
- GraphLens previousLens,
- DexItemFactory dexItemFactory,
- Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod,
- Set<DexType> unboxedEnums) {
- super(
- typeMap,
- methodMap,
- fieldMap,
- originalFieldSignatures,
- originalMethodSignatures,
- previousLens,
- dexItemFactory);
- this.prototypeChangesPerMethod = prototypeChangesPerMethod;
- this.unboxedEnums = unboxedEnums;
- }
-
- @Override
- protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
- RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
- // During the second IR processing enum unboxing is the only optimization rewriting
- // prototype description, if this does not hold, remove the assertion and merge
- // the two prototype changes.
- assert prototypeChanges.isEmpty();
- return prototypeChangesPerMethod.getOrDefault(method, RewrittenPrototypeDescription.none());
- }
-
- @Override
- protected Invoke.Type mapInvocationType(
- DexMethod newMethod, DexMethod originalMethod, Invoke.Type type) {
- if (unboxedEnums.contains(originalMethod.holder)) {
- // Methods moved from unboxed enums to the utility class are either static or statified.
- assert newMethod != originalMethod;
- return Invoke.Type.STATIC;
- }
- return type;
- }
-
- public static Builder builder() {
- return new Builder();
- }
-
- private static class Builder extends NestedGraphLens.Builder {
-
- private Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod =
- new IdentityHashMap<>();
-
- public void move(DexMethod from, boolean fromStatic, DexMethod to, boolean toStatic) {
- move(from, fromStatic, to, toStatic, 0);
- }
-
- public void move(
- DexMethod from,
- boolean fromStatic,
- DexMethod to,
- boolean toStatic,
- int numberOfExtraNullParameters) {
- super.move(from, to);
- int offsetDiff = 0;
- int toOffset = BooleanUtils.intValue(!toStatic);
- ArgumentInfoCollection.Builder builder = ArgumentInfoCollection.builder();
- if (fromStatic != toStatic) {
- assert toStatic;
- offsetDiff = 1;
- builder.addArgumentInfo(
- 0, new RewrittenTypeInfo(from.holder, to.proto.parameters.values[0]));
- }
- for (int i = 0; i < from.proto.parameters.size(); i++) {
- DexType fromType = from.proto.parameters.values[i];
- DexType toType = to.proto.parameters.values[i + offsetDiff];
- if (fromType != toType) {
- builder.addArgumentInfo(
- i + offsetDiff + toOffset, new RewrittenTypeInfo(fromType, toType));
- }
- }
- RewrittenTypeInfo returnInfo =
- from.proto.returnType == to.proto.returnType
- ? null
- : new RewrittenTypeInfo(from.proto.returnType, to.proto.returnType);
- prototypeChangesPerMethod.put(
- to,
- RewrittenPrototypeDescription.createForRewrittenTypes(returnInfo, builder.build())
- .withExtraUnusedNullParameters(numberOfExtraNullParameters));
- }
-
- public EnumUnboxingLens build(
- DexItemFactory dexItemFactory, GraphLens previousLens, Set<DexType> unboxedEnums) {
- if (typeMap.isEmpty() && methodMap.isEmpty() && fieldMap.isEmpty()) {
- return null;
- }
- return new EnumUnboxingLens(
- typeMap,
- methodMap,
- fieldMap,
- originalFieldSignatures,
- originalMethodSignatures,
- previousLens,
- dexItemFactory,
- ImmutableMap.copyOf(prototypeChangesPerMethod),
- ImmutableSet.copyOf(unboxedEnums));
- }
- }
- }
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
index b5a5b62..e0b6ff5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
@@ -16,9 +16,6 @@
import com.android.tools.r8.ir.optimize.enums.EnumUnboxer.Reason;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.KeepInfoCollection;
-import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
class EnumUnboxingCandidateAnalysis {
@@ -30,7 +27,8 @@
private final AppView<AppInfoWithLiveness> appView;
private final EnumUnboxer enumUnboxer;
private final DexItemFactory factory;
- private Map<DexType, ProgramMethodSet> enumToUnboxCandidates = new ConcurrentHashMap<>();
+ private EnumUnboxingCandidateInfoCollection enumToUnboxCandidates =
+ new EnumUnboxingCandidateInfoCollection();
EnumUnboxingCandidateAnalysis(AppView<AppInfoWithLiveness> appView, EnumUnboxer enumUnboxer) {
this.appView = appView;
@@ -38,16 +36,16 @@
factory = appView.dexItemFactory();
}
- Map<DexType, ProgramMethodSet> findCandidates() {
+ EnumUnboxingCandidateInfoCollection findCandidates() {
for (DexProgramClass clazz : appView.appInfo().classes()) {
if (isEnumUnboxingCandidate(clazz)) {
- enumToUnboxCandidates.put(clazz.type, ProgramMethodSet.createConcurrent());
+ enumToUnboxCandidates.addCandidate(clazz);
}
}
removeEnumsInAnnotations();
removePinnedCandidates();
if (appView.options().protoShrinking().isProtoShrinkingEnabled()) {
- enumToUnboxCandidates.remove(appView.protoShrinker().references.methodToInvokeType);
+ enumToUnboxCandidates.removeCandidate(appView.protoShrinker().references.methodToInvokeType);
}
return enumToUnboxCandidates;
}
@@ -114,9 +112,9 @@
assert method.parameters().isEmpty()
|| appView.options().testing.allowInjectedAnnotationMethods;
DexType valueType = method.returnType().toBaseType(appView.dexItemFactory());
- if (enumToUnboxCandidates.containsKey(valueType)) {
+ if (enumToUnboxCandidates.isCandidate(valueType)) {
enumUnboxer.reportFailure(valueType, Reason.ANNOTATION);
- enumToUnboxCandidates.remove(valueType);
+ enumToUnboxCandidates.removeCandidate(valueType);
}
}
}
@@ -146,9 +144,9 @@
}
private void removePinnedCandidate(DexType type) {
- if (enumToUnboxCandidates.containsKey(type)) {
+ if (enumToUnboxCandidates.isCandidate(type)) {
enumUnboxer.reportFailure(type, Reason.PINNED);
- enumToUnboxCandidates.remove(type);
+ enumToUnboxCandidates.removeCandidate(type);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java
new file mode 100644
index 0000000..947cc6d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java
@@ -0,0 +1,134 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.enums;
+
+import com.android.tools.r8.graph.DexField;
+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.collections.ProgramMethodSet;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public class EnumUnboxingCandidateInfoCollection {
+
+ private final Map<DexType, EnumUnboxingCandidateInfo> enumTypeToInfo = new ConcurrentHashMap<>();
+
+ public void addCandidate(DexProgramClass enumClass) {
+ assert !enumTypeToInfo.containsKey(enumClass.type);
+ enumTypeToInfo.put(enumClass.type, new EnumUnboxingCandidateInfo(enumClass));
+ }
+
+ public void removeCandidate(DexType enumType) {
+ enumTypeToInfo.remove(enumType);
+ }
+
+ public boolean isCandidate(DexType enumType) {
+ return enumTypeToInfo.containsKey(enumType);
+ }
+
+ public boolean isEmpty() {
+ return enumTypeToInfo.isEmpty();
+ }
+
+ public ImmutableSet<DexType> candidates() {
+ return ImmutableSet.copyOf(enumTypeToInfo.keySet());
+ }
+
+ public ImmutableSet<DexProgramClass> candidateClasses() {
+ ImmutableSet.Builder<DexProgramClass> builder = ImmutableSet.builder();
+ for (EnumUnboxingCandidateInfo info : enumTypeToInfo.values()) {
+ builder.add(info.getEnumClass());
+ }
+ return builder.build();
+ }
+
+ public DexProgramClass getCandidateClassOrNull(DexType enumType) {
+ EnumUnboxingCandidateInfo info = enumTypeToInfo.get(enumType);
+ if (info == null) {
+ return null;
+ }
+ return info.enumClass;
+ }
+
+ public ProgramMethodSet allMethodDependencies() {
+ ProgramMethodSet allMethodDependencies = ProgramMethodSet.create();
+ for (EnumUnboxingCandidateInfo info : enumTypeToInfo.values()) {
+ allMethodDependencies.addAll(info.methodDependencies);
+ }
+ return allMethodDependencies;
+ }
+
+ public void addMethodDependency(DexType enumType, ProgramMethod programMethod) {
+ // The enumType may be removed concurrently map from enumTypeToInfo. It means in that
+ // case the enum is no longer a candidate, and dependencies don't need to be recorded
+ // anymore.
+ EnumUnboxingCandidateInfo info = enumTypeToInfo.get(enumType);
+ if (info == null) {
+ return;
+ }
+ info.addMethodDependency(programMethod);
+ }
+
+ public void addRequiredEnumInstanceFieldData(DexType enumType, DexField field) {
+ // The enumType may be removed concurrently map from enumTypeToInfo. It means in that
+ // case the enum is no longer a candidate, and dependencies don't need to be recorded
+ // anymore.
+ EnumUnboxingCandidateInfo info = enumTypeToInfo.get(enumType);
+ if (info == null) {
+ return;
+ }
+ info.addRequiredInstanceFieldData(field);
+ }
+
+ public void forEachCandidate(Consumer<DexProgramClass> enumClassConsumer) {
+ enumTypeToInfo.values().forEach(info -> enumClassConsumer.accept(info.enumClass));
+ }
+
+ public void forEachCandidateAndRequiredInstanceFieldData(
+ BiConsumer<DexProgramClass, Set<DexField>> biConsumer) {
+ enumTypeToInfo
+ .values()
+ .forEach(
+ info -> biConsumer.accept(info.getEnumClass(), info.getRequiredInstanceFieldData()));
+ }
+
+ public void clear() {
+ enumTypeToInfo.clear();
+ }
+
+ private static class EnumUnboxingCandidateInfo {
+
+ private final DexProgramClass enumClass;
+ private final ProgramMethodSet methodDependencies = ProgramMethodSet.createConcurrent();
+ private final Set<DexField> requiredInstanceFieldData = Sets.newConcurrentHashSet();
+
+ public EnumUnboxingCandidateInfo(DexProgramClass enumClass) {
+ assert enumClass != null;
+ this.enumClass = enumClass;
+ }
+
+ public DexProgramClass getEnumClass() {
+ return enumClass;
+ }
+
+ public void addMethodDependency(ProgramMethod programMethod) {
+ methodDependencies.add(programMethod);
+ }
+
+ public void addRequiredInstanceFieldData(DexField field) {
+ requiredInstanceFieldData.add(field);
+ }
+
+ public Set<DexField> getRequiredInstanceFieldData() {
+ return requiredInstanceFieldData;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingLens.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingLens.java
new file mode 100644
index 0000000..869cb6e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingLens.java
@@ -0,0 +1,139 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.enums;
+
+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.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.ir.code.Invoke;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+class EnumUnboxingLens extends GraphLens.NestedGraphLens {
+
+ private final Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod;
+ private final Set<DexType> unboxedEnums;
+
+ EnumUnboxingLens(
+ Map<DexType, DexType> typeMap,
+ Map<DexMethod, DexMethod> methodMap,
+ Map<DexField, DexField> fieldMap,
+ BiMap<DexField, DexField> originalFieldSignatures,
+ BiMap<DexMethod, DexMethod> originalMethodSignatures,
+ GraphLens previousLens,
+ DexItemFactory dexItemFactory,
+ Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod,
+ Set<DexType> unboxedEnums) {
+ super(
+ typeMap,
+ methodMap,
+ fieldMap,
+ originalFieldSignatures,
+ originalMethodSignatures,
+ previousLens,
+ dexItemFactory);
+ this.prototypeChangesPerMethod = prototypeChangesPerMethod;
+ this.unboxedEnums = unboxedEnums;
+ }
+
+ @Override
+ protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+ RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
+ // During the second IR processing enum unboxing is the only optimization rewriting
+ // prototype description, if this does not hold, remove the assertion and merge
+ // the two prototype changes.
+ assert prototypeChanges.isEmpty();
+ return prototypeChangesPerMethod.getOrDefault(method, RewrittenPrototypeDescription.none());
+ }
+
+ @Override
+ protected Invoke.Type mapInvocationType(
+ DexMethod newMethod, DexMethod originalMethod, Invoke.Type type) {
+ if (unboxedEnums.contains(originalMethod.holder)) {
+ // Methods moved from unboxed enums to the utility class are either static or statified.
+ assert newMethod != originalMethod;
+ return Invoke.Type.STATIC;
+ }
+ return type;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ static class Builder extends NestedGraphLens.Builder {
+
+ private Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod =
+ new IdentityHashMap<>();
+
+ public void move(DexMethod from, boolean fromStatic, DexMethod to, boolean toStatic) {
+ move(from, fromStatic, to, toStatic, 0);
+ }
+
+ public void move(
+ DexMethod from,
+ boolean fromStatic,
+ DexMethod to,
+ boolean toStatic,
+ int numberOfExtraNullParameters) {
+ super.move(from, to);
+ int offsetDiff = 0;
+ int toOffset = BooleanUtils.intValue(!toStatic);
+ RewrittenPrototypeDescription.ArgumentInfoCollection.Builder builder =
+ RewrittenPrototypeDescription.ArgumentInfoCollection.builder();
+ if (fromStatic != toStatic) {
+ assert toStatic;
+ offsetDiff = 1;
+ builder.addArgumentInfo(
+ 0,
+ new RewrittenPrototypeDescription.RewrittenTypeInfo(
+ from.holder, to.proto.parameters.values[0]));
+ }
+ for (int i = 0; i < from.proto.parameters.size(); i++) {
+ DexType fromType = from.proto.parameters.values[i];
+ DexType toType = to.proto.parameters.values[i + offsetDiff];
+ if (fromType != toType) {
+ builder.addArgumentInfo(
+ i + offsetDiff + toOffset,
+ new RewrittenPrototypeDescription.RewrittenTypeInfo(fromType, toType));
+ }
+ }
+ RewrittenPrototypeDescription.RewrittenTypeInfo returnInfo =
+ from.proto.returnType == to.proto.returnType
+ ? null
+ : new RewrittenPrototypeDescription.RewrittenTypeInfo(
+ from.proto.returnType, to.proto.returnType);
+ prototypeChangesPerMethod.put(
+ to,
+ RewrittenPrototypeDescription.createForRewrittenTypes(returnInfo, builder.build())
+ .withExtraUnusedNullParameters(numberOfExtraNullParameters));
+ }
+
+ public EnumUnboxingLens build(
+ DexItemFactory dexItemFactory, GraphLens previousLens, Set<DexType> unboxedEnums) {
+ if (typeMap.isEmpty() && methodMap.isEmpty() && fieldMap.isEmpty()) {
+ return null;
+ }
+ return new EnumUnboxingLens(
+ typeMap,
+ methodMap,
+ fieldMap,
+ originalFieldSignatures,
+ originalMethodSignatures,
+ previousLens,
+ dexItemFactory,
+ ImmutableMap.copyOf(prototypeChangesPerMethod),
+ ImmutableSet.copyOf(unboxedEnums));
+ }
+ }
+}
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 6c73aef..c67c231 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
@@ -9,23 +9,23 @@
import com.android.tools.r8.dex.Constants;
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.DexEncodedMember;
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.DexMember;
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.DexTypeList;
import com.android.tools.r8.graph.EnumValueInfoMapCollection;
import com.android.tools.r8.graph.EnumValueInfoMapCollection.EnumValueInfo;
import com.android.tools.r8.graph.EnumValueInfoMapCollection.EnumValueInfoMap;
import com.android.tools.r8.graph.FieldAccessFlags;
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.analysis.type.ArrayTypeElement;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -46,11 +46,12 @@
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldKnownData;
import com.android.tools.r8.ir.synthetic.EnumUnboxingCfCodeProvider;
-import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
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.IdentityHashMap;
import java.util.List;
@@ -63,7 +64,6 @@
public class EnumUnboxingRewriter {
- public static final String ENUM_UNBOXING_UTILITY_CLASS_NAME = "$r8$EnumUnboxingUtility";
public static final String ENUM_UNBOXING_UTILITY_METHOD_PREFIX = "$enumboxing$";
private static final int REQUIRED_CLASS_FILE_VERSION = 52;
@@ -71,8 +71,10 @@
private final DexItemFactory factory;
private final EnumValueInfoMapCollection enumsToUnbox;
private final EnumInstanceFieldDataMap unboxedEnumsInstanceFieldData;
+ private final UnboxedEnumMemberRelocator relocator;
+
private final Map<DexMethod, DexEncodedMethod> utilityMethods = new ConcurrentHashMap<>();
- private final Map<DexField, DexEncodedField> extraUtilityFields = new ConcurrentHashMap<>();
+ private final Map<DexField, DexEncodedField> utilityFields = new ConcurrentHashMap<>();
private final DexMethod ordinalUtilityMethod;
private final DexMethod equalsUtilityMethod;
@@ -84,7 +86,8 @@
EnumUnboxingRewriter(
AppView<AppInfoWithLiveness> appView,
Set<DexType> enumsToUnbox,
- EnumInstanceFieldDataMap unboxedEnumsInstanceFieldData) {
+ EnumInstanceFieldDataMap unboxedEnumsInstanceFieldData,
+ UnboxedEnumMemberRelocator relocator) {
this.appView = appView;
this.factory = appView.dexItemFactory();
EnumValueInfoMapCollection.Builder builder = EnumValueInfoMapCollection.builder();
@@ -94,38 +97,40 @@
}
this.enumsToUnbox = builder.build();
this.unboxedEnumsInstanceFieldData = unboxedEnumsInstanceFieldData;
+ this.relocator = relocator;
// Custom methods for java.lang.Enum methods ordinal, equals and compareTo.
+ DexType defaultEnumUnboxingUtility = relocator.getDefaultEnumUnboxingUtility();
this.ordinalUtilityMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.intType, factory.intType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "ordinal");
this.equalsUtilityMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.booleanType, factory.intType, factory.intType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "equals");
this.compareToUtilityMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.intType, factory.intType, factory.intType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "compareTo");
// Custom methods for generated field $VALUES initialization.
this.valuesUtilityMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.intArrayType, factory.intType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "values");
// Custom methods for Object#getClass without outValue and Objects.requireNonNull.
this.zeroCheckMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.voidType, factory.intType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "zeroCheck");
this.zeroCheckMessageMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ defaultEnumUnboxingUtility,
factory.createProto(factory.voidType, factory.intType, factory.stringType),
ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "zeroCheckMessage");
}
@@ -261,7 +266,7 @@
utilityMethods.computeIfAbsent(
valuesUtilityMethod, m -> synthesizeValuesUtilityMethod());
DexField fieldValues = createValuesField(holder);
- extraUtilityFields.computeIfAbsent(fieldValues, this::computeValuesEncodedField);
+ utilityFields.computeIfAbsent(fieldValues, this::computeValuesEncodedField);
DexMethod methodValues = createValuesMethod(holder);
utilityMethods.computeIfAbsent(
methodValues,
@@ -368,11 +373,11 @@
return type.toSourceString().replace('.', '$');
}
- private DexField createValuesField(DexType type) {
+ private DexField createValuesField(DexType enumType) {
return factory.createField(
- factory.enumUnboxingUtilityType,
+ relocator.getNewMemberLocationFor(enumType),
factory.intArrayType,
- factory.enumValuesFieldName + "$field$" + compatibleName(type));
+ factory.enumValuesFieldName + "$field$" + compatibleName(enumType));
}
private DexEncodedField computeValuesEncodedField(DexField field) {
@@ -384,22 +389,18 @@
null);
}
- private DexMethod createValuesMethod(DexType type) {
+ private DexMethod createValuesMethod(DexType enumType) {
return factory.createMethod(
- factory.enumUnboxingUtilityType,
+ relocator.getNewMemberLocationFor(enumType),
factory.createProto(factory.intArrayType),
- factory.enumValuesFieldName + "$method$" + compatibleName(type));
+ factory.enumValuesFieldName + "$method$" + compatibleName(enumType));
}
private DexEncodedMethod computeValuesEncodedMethod(
DexMethod method, DexField fieldValues, int numEnumInstances) {
CfCode cfCode =
new EnumUnboxingCfCodeProvider.EnumUnboxingValuesCfCodeProvider(
- appView,
- factory.enumUnboxingUtilityType,
- fieldValues,
- numEnumInstances,
- valuesUtilityMethod)
+ appView, method.holder, fieldValues, numEnumInstances, valuesUtilityMethod)
.generateCfCode();
return synthesizeUtilityMethod(cfCode, method, true);
}
@@ -415,7 +416,7 @@
+ compatibleName(enumType);
DexMethod fieldMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ relocator.getNewMemberLocationFor(enumType),
factory.createProto(field.type, factory.intType),
methodName);
utilityMethods.computeIfAbsent(
@@ -429,7 +430,7 @@
String methodName = "string$valueOf$" + compatibleName(enumType);
DexMethod fieldMethod =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ relocator.getNewMemberLocationFor(enumType),
factory.createProto(factory.stringType, factory.intType),
methodName);
AbstractValue nullString =
@@ -440,14 +441,14 @@
return fieldMethod;
}
- private DexMethod computeValueOfUtilityMethod(DexType type) {
- assert enumsToUnbox.containsEnum(type);
+ private DexMethod computeValueOfUtilityMethod(DexType enumType) {
+ assert enumsToUnbox.containsEnum(enumType);
DexMethod valueOf =
factory.createMethod(
- factory.enumUnboxingUtilityType,
+ relocator.getNewMemberLocationFor(enumType),
factory.createProto(factory.intType, factory.stringType),
- "valueOf" + compatibleName(type));
- utilityMethods.computeIfAbsent(valueOf, m -> synthesizeValueOfUtilityMethod(m, type));
+ "valueOf" + compatibleName(enumType));
+ utilityMethods.computeIfAbsent(valueOf, m -> synthesizeValueOfUtilityMethod(m, enumType));
return valueOf;
}
@@ -468,50 +469,52 @@
return enumsToUnbox.containsEnum(classType) ? classType : null;
}
- void synthesizeEnumUnboxingUtilityMethods(
- Builder<?> builder, IRConverter converter, ExecutorService executorService)
+ void synthesizeEnumUnboxingUtilityMethods(IRConverter converter, ExecutorService executorService)
throws ExecutionException {
- // Synthesize a class which holds various utility methods that may be called from the IR
- // rewriting. If any of these methods are not used, they will be removed by the Enqueuer.
- List<DexEncodedMethod> requiredMethods = new ArrayList<>(utilityMethods.values());
- // Sort for deterministic order.
- requiredMethods.sort((m1, m2) -> m1.method.name.slowCompareTo(m2.method.name));
- if (requiredMethods.isEmpty()) {
+ // Append to the various utility classes, in deterministic order, the utility methods and
+ // fields required.
+ Map<DexType, List<DexEncodedMethod>> methodMap = triageEncodedMembers(utilityMethods.values());
+ if (methodMap.isEmpty()) {
+ assert utilityFields.isEmpty();
return;
}
- List<DexEncodedField> fields = new ArrayList<>(extraUtilityFields.values());
- fields.sort((f1, f2) -> f1.field.name.slowCompareTo(f2.field.name));
- DexProgramClass utilityClass =
- appView.definitionForProgramType(factory.enumUnboxingUtilityType);
- assert utilityClass != null : "Should have been synthesized upfront.";
- utilityClass.appendStaticFields(fields);
- utilityClass.addDirectMethods(requiredMethods);
- assert requiredMethods.stream().allMatch(DexEncodedMethod::isPublic);
- // TODO(b/147860220): Use processMethodsConcurrently on requiredMethods instead.
- converter.optimizeSynthesizedClass(utilityClass, executorService);
+ SortedProgramMethodSet wave = SortedProgramMethodSet.create();
+ methodMap.forEach(
+ (type, methodsSorted) -> {
+ DexProgramClass utilityClass = appView.definitionFor(type).asProgramClass();
+ assert utilityClass != null;
+ utilityClass.addDirectMethods(methodsSorted);
+ for (DexEncodedMethod dexEncodedMethod : methodsSorted) {
+ wave.add(new ProgramMethod(utilityClass, dexEncodedMethod));
+ }
+ });
+ Map<DexType, List<DexEncodedField>> fieldMap = triageEncodedMembers(utilityFields.values());
+ fieldMap.forEach(
+ (type, fieldsSorted) -> {
+ DexProgramClass utilityClass = appView.definitionFor(type).asProgramClass();
+ assert utilityClass != null;
+ utilityClass.appendStaticFields(fieldsSorted);
+ });
+ converter.processMethodsConcurrently(wave, executorService);
}
- public static DexProgramClass synthesizeEmptyEnumUnboxingUtilityClass(AppView<?> appView) {
- DexItemFactory factory = appView.dexItemFactory();
- return new DexProgramClass(
- factory.enumUnboxingUtilityType,
- null,
- new SynthesizedOrigin("EnumUnboxing ", EnumUnboxingRewriter.class),
- ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC),
- factory.objectType,
- DexTypeList.empty(),
- factory.createString("enumunboxing"),
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- DexEncodedMethod.EMPTY_ARRAY,
- factory.getSkipNameValidationForTesting(),
- DexProgramClass::checksumFromType);
+ <R extends DexMember<T, R>, T extends DexEncodedMember<T, R>>
+ Map<DexType, List<T>> triageEncodedMembers(Collection<T> encodedMembers) {
+ if (encodedMembers.isEmpty()) {
+ return Collections.emptyMap();
+ }
+ Map<DexType, List<T>> encodedMembersMap = new IdentityHashMap<>();
+ // We compute encodedMembers by types.
+ for (T encodedMember : encodedMembers) {
+ List<T> members =
+ encodedMembersMap.computeIfAbsent(encodedMember.holder(), ignored -> new ArrayList<>());
+ members.add(encodedMember);
+ }
+ // We make the order deterministic.
+ for (List<T> value : encodedMembersMap.values()) {
+ value.sort((m1, m2) -> m1.toReference().slowCompareTo(m2.toReference()));
+ }
+ return encodedMembersMap;
}
private DexEncodedMethod synthesizeInstanceFieldMethod(
@@ -521,7 +524,7 @@
CfCode cfCode =
new EnumUnboxingCfCodeProvider.EnumUnboxingInstanceFieldCfCodeProvider(
appView,
- factory.enumUnboxingUtilityType,
+ method.holder,
field.type,
enumsToUnbox.getEnumValueInfoMap(enumType),
unboxedEnumsInstanceFieldData
@@ -540,7 +543,7 @@
CfCode cfCode =
new EnumUnboxingCfCodeProvider.EnumUnboxingValueOfCfCodeProvider(
appView,
- factory.enumUnboxingUtilityType,
+ method.holder,
enumType,
enumsToUnbox.getEnumValueInfoMap(enumType),
unboxedEnumsInstanceFieldData
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
new file mode 100644
index 0000000..879c909
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
@@ -0,0 +1,221 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.enums;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
+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;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.utils.OptionalBool;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+class EnumUnboxingTreeFixer {
+
+ private final Map<DexType, List<DexEncodedMethod>> unboxedEnumsMethods = new IdentityHashMap<>();
+ private final EnumUnboxingLens.Builder lensBuilder = EnumUnboxingLens.builder();
+ private final AppView<?> appView;
+ private final DexItemFactory factory;
+ private final Set<DexType> enumsToUnbox;
+ private final UnboxedEnumMemberRelocator relocator;
+ private final EnumUnboxingRewriter enumUnboxerRewriter;
+
+ EnumUnboxingTreeFixer(
+ AppView<?> appView,
+ Set<DexType> enumsToUnbox,
+ UnboxedEnumMemberRelocator relocator,
+ EnumUnboxingRewriter enumUnboxerRewriter) {
+ this.appView = appView;
+ this.factory = appView.dexItemFactory();
+ this.enumsToUnbox = enumsToUnbox;
+ this.relocator = relocator;
+ this.enumUnboxerRewriter = enumUnboxerRewriter;
+ }
+
+ GraphLens.NestedGraphLens fixupTypeReferences() {
+ assert enumUnboxerRewriter != null;
+ // Fix all methods and fields using enums to unbox.
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ if (enumsToUnbox.contains(clazz.type)) {
+ // Clear the initializers and move the static methods to the new location.
+ Set<DexEncodedMethod> methodsToRemove = Sets.newIdentityHashSet();
+ clazz
+ .methods()
+ .forEach(
+ m -> {
+ if (m.isInitializer()) {
+ clearEnumToUnboxMethod(m);
+ } else {
+ DexType newHolder = relocator.getNewMemberLocationFor(clazz.type);
+ List<DexEncodedMethod> movedMethods =
+ unboxedEnumsMethods.computeIfAbsent(newHolder, k -> new ArrayList<>());
+ movedMethods.add(fixupEncodedMethodToUtility(m, newHolder));
+ methodsToRemove.add(m);
+ }
+ });
+ clazz.getMethodCollection().removeMethods(methodsToRemove);
+ } else {
+ clazz.getMethodCollection().replaceMethods(this::fixupEncodedMethod);
+ fixupFields(clazz.staticFields(), clazz::setStaticField);
+ fixupFields(clazz.instanceFields(), clazz::setInstanceField);
+ }
+ }
+ for (DexType toUnbox : enumsToUnbox) {
+ lensBuilder.map(toUnbox, factory.intType);
+ }
+ unboxedEnumsMethods.forEach(
+ (newHolderType, movedMethods) -> {
+ DexProgramClass newHolderClass = appView.definitionFor(newHolderType).asProgramClass();
+ newHolderClass.addDirectMethods(movedMethods);
+ });
+ return lensBuilder.build(factory, appView.graphLens(), enumsToUnbox);
+ }
+
+ private void clearEnumToUnboxMethod(DexEncodedMethod enumMethod) {
+ // The compiler may have references to the enum methods, but such methods will be removed
+ // and they cannot be reprocessed since their rewriting through the lensCodeRewriter/
+ // enumUnboxerRewriter will generate invalid code.
+ // To work around this problem we clear such methods, i.e., we replace the code object by
+ // an empty throwing code object, so reprocessing won't take time and will be valid.
+ enumMethod.setCode(enumMethod.buildEmptyThrowingCode(appView.options()), appView);
+ }
+
+ private DexEncodedMethod fixupEncodedMethodToUtility(
+ DexEncodedMethod encodedMethod, DexType newHolder) {
+ DexMethod method = encodedMethod.method;
+ DexString newMethodName =
+ factory.createString(
+ enumUnboxerRewriter.compatibleName(method.holder)
+ + "$"
+ + (encodedMethod.isStatic() ? "s" : "v")
+ + "$"
+ + method.name.toString());
+ DexProto proto = encodedMethod.isStatic() ? method.proto : factory.prependHolderToProto(method);
+ DexMethod newMethod = factory.createMethod(newHolder, fixupProto(proto), newMethodName);
+ assert appView.definitionFor(encodedMethod.holder()).lookupMethod(newMethod) == null;
+ lensBuilder.move(method, encodedMethod.isStatic(), newMethod, true);
+ encodedMethod.accessFlags.promoteToPublic();
+ encodedMethod.accessFlags.promoteToStatic();
+ encodedMethod.clearAnnotations();
+ encodedMethod.clearParameterAnnotations();
+ return encodedMethod.toTypeSubstitutedMethod(newMethod);
+ }
+
+ private DexEncodedMethod fixupEncodedMethod(DexEncodedMethod encodedMethod) {
+ DexProto newProto = fixupProto(encodedMethod.proto());
+ if (newProto == encodedMethod.proto()) {
+ return encodedMethod;
+ }
+ assert !encodedMethod.isClassInitializer();
+ // We add the $enumunboxing$ suffix to make sure we do not create a library override.
+ String newMethodName =
+ encodedMethod.getName().toString()
+ + (encodedMethod.isNonPrivateVirtualMethod() ? "$enumunboxing$" : "");
+ DexMethod newMethod = factory.createMethod(encodedMethod.holder(), newProto, newMethodName);
+ newMethod = ensureUniqueMethod(encodedMethod, newMethod);
+ int numberOfExtraNullParameters = newMethod.getArity() - encodedMethod.method.getArity();
+ boolean isStatic = encodedMethod.isStatic();
+ lensBuilder.move(
+ encodedMethod.method, isStatic, newMethod, isStatic, numberOfExtraNullParameters);
+ DexEncodedMethod newEncodedMethod = encodedMethod.toTypeSubstitutedMethod(newMethod);
+ assert !encodedMethod.isLibraryMethodOverride().isTrue()
+ : "Enum unboxing is changing the signature of a library override in a non unboxed class.";
+ if (newEncodedMethod.isNonPrivateVirtualMethod()) {
+ newEncodedMethod.setLibraryMethodOverride(OptionalBool.FALSE);
+ }
+ return newEncodedMethod;
+ }
+
+ private DexMethod ensureUniqueMethod(DexEncodedMethod encodedMethod, DexMethod newMethod) {
+ DexClass holder = appView.definitionFor(encodedMethod.holder());
+ assert holder != null;
+ if (encodedMethod.isInstanceInitializer()) {
+ while (holder.lookupMethod(newMethod) != null) {
+ newMethod =
+ factory.createMethod(
+ newMethod.holder,
+ factory.appendTypeToProto(
+ newMethod.proto, relocator.getDefaultEnumUnboxingUtility()),
+ newMethod.name);
+ }
+ } else {
+ int index = 0;
+ while (holder.lookupMethod(newMethod) != null) {
+ newMethod =
+ factory.createMethod(
+ newMethod.holder,
+ newMethod.proto,
+ encodedMethod.getName().toString() + "$enumunboxing$" + index++);
+ }
+ }
+ return newMethod;
+ }
+
+ private void fixupFields(List<DexEncodedField> fields, DexClass.FieldSetter setter) {
+ if (fields == null) {
+ return;
+ }
+ for (int i = 0; i < fields.size(); i++) {
+ DexEncodedField encodedField = fields.get(i);
+ DexField field = encodedField.field;
+ DexType newType = fixupType(field.type);
+ if (newType != field.type) {
+ DexField newField = factory.createField(field.holder, newType, field.name);
+ lensBuilder.move(field, newField);
+ DexEncodedField newEncodedField = encodedField.toTypeSubstitutedField(newField);
+ setter.setField(i, newEncodedField);
+ if (encodedField.isStatic() && encodedField.hasExplicitStaticValue()) {
+ assert encodedField.getStaticValue() == DexValue.DexValueNull.NULL;
+ newEncodedField.setStaticValue(DexValue.DexValueInt.DEFAULT);
+ // TODO(b/150593449): Support conversion from DexValueEnum to DexValueInt.
+ }
+ }
+ }
+ }
+
+ private DexProto fixupProto(DexProto proto) {
+ DexType returnType = fixupType(proto.returnType);
+ DexType[] arguments = fixupTypes(proto.parameters.values);
+ return factory.createProto(returnType, arguments);
+ }
+
+ private DexType fixupType(DexType type) {
+ if (type.isArrayType()) {
+ DexType base = type.toBaseType(factory);
+ DexType fixed = fixupType(base);
+ if (base == fixed) {
+ return type;
+ }
+ return type.replaceBaseType(fixed, factory);
+ }
+ if (type.isClassType() && enumsToUnbox.contains(type)) {
+ DexType intType = factory.intType;
+ lensBuilder.map(type, intType);
+ return intType;
+ }
+ return type;
+ }
+
+ private DexType[] fixupTypes(DexType[] types) {
+ DexType[] result = new DexType[types.length];
+ for (int i = 0; i < result.length; i++) {
+ result[i] = fixupType(types[i]);
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java
new file mode 100644
index 0000000..16c9118
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java
@@ -0,0 +1,151 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.enums;
+
+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.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.graph.ProgramPackage;
+import com.android.tools.r8.graph.ProgramPackageCollection;
+import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.google.common.collect.ImmutableMap;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class UnboxedEnumMemberRelocator {
+
+ public static final String ENUM_UNBOXING_UTILITY_CLASS_SUFFIX = "$r8$EnumUnboxingUtility";
+
+ // Default enum unboxing utility synthetic class used to hold all the shared unboxed enum
+ // methods (ordinal(I), equals(II), etc.) and the unboxed enums members which were free to be
+ // placed anywhere.
+ private final DexType defaultEnumUnboxingUtility;
+ // Some unboxed enum members have to be placed in a specific package, in this case, we keep a
+ // map from unboxed enum types to synthetic classes, so that all members of unboxed enums in the
+ // keys are moved to the corresponding value.
+ private final ImmutableMap<DexType, DexType> relocationMap;
+
+ public DexType getDefaultEnumUnboxingUtility() {
+ return defaultEnumUnboxingUtility;
+ }
+
+ public DexType getNewMemberLocationFor(DexType enumType) {
+ return relocationMap.getOrDefault(enumType, defaultEnumUnboxingUtility);
+ }
+
+ private UnboxedEnumMemberRelocator(
+ DexType defaultEnumUnboxingUtility, ImmutableMap<DexType, DexType> relocationMap) {
+ this.defaultEnumUnboxingUtility = defaultEnumUnboxingUtility;
+ this.relocationMap = relocationMap;
+ }
+
+ public static Builder builder(AppView<?> appView) {
+ return new Builder(appView);
+ }
+
+ public static class Builder {
+ private DexType defaultEnumUnboxingUtility;
+ private Map<DexType, DexType> relocationMap = new IdentityHashMap<>();
+ private final AppView<?> appView;
+
+ public Builder(AppView<?> appView) {
+ this.appView = appView;
+ }
+
+ public Builder synthesizeEnumUnboxingUtilityClasses(
+ Set<DexProgramClass> enumsToUnbox,
+ ProgramPackageCollection enumsToUnboxWithPackageRequirement,
+ DirectMappedDexApplication.Builder appBuilder) {
+ defaultEnumUnboxingUtility = synthesizeUtilityClass(enumsToUnbox, appBuilder);
+ if (!enumsToUnboxWithPackageRequirement.isEmpty()) {
+ synthesizeRelocationMap(enumsToUnboxWithPackageRequirement, appBuilder);
+ }
+ return this;
+ }
+
+ public UnboxedEnumMemberRelocator build() {
+ return new UnboxedEnumMemberRelocator(
+ defaultEnumUnboxingUtility, ImmutableMap.copyOf(relocationMap));
+ }
+
+ private void synthesizeRelocationMap(
+ ProgramPackageCollection enumsToUnboxWithPackageRequirement,
+ DirectMappedDexApplication.Builder appBuilder) {
+ for (ProgramPackage programPackage : enumsToUnboxWithPackageRequirement) {
+ Set<DexProgramClass> enumsToUnboxInPackage = programPackage.classesInPackage();
+ DexType utilityType = synthesizeUtilityClass(enumsToUnboxInPackage, appBuilder);
+ for (DexProgramClass enumToUnbox : enumsToUnboxInPackage) {
+ assert !relocationMap.containsKey(enumToUnbox.type);
+ relocationMap.put(enumToUnbox.type, utilityType);
+ }
+ }
+ }
+
+ private DexType synthesizeUtilityClass(
+ Set<DexProgramClass> contexts, DirectMappedDexApplication.Builder appBuilder) {
+ DexType deterministicContextType = findDeterministicContextType(contexts);
+ assert deterministicContextType.isClassType();
+ String descriptorString = deterministicContextType.toDescriptorString();
+ String descriptorPrefix = descriptorString.substring(0, descriptorString.length() - 1);
+ String syntheticClassDescriptor = descriptorPrefix + ENUM_UNBOXING_UTILITY_CLASS_SUFFIX + ";";
+ DexType type = appView.dexItemFactory().createType(syntheticClassDescriptor);
+ // The defaultEnumUnboxingUtility depends on all unboxable enums, and other synthetic types
+ // depend on a subset of the unboxable enums, the deterministicContextType can therefore
+ // be found twice, and in that case the same utility class can be used for both.
+ if (type == defaultEnumUnboxingUtility) {
+ return defaultEnumUnboxingUtility;
+ }
+ assert appView.appInfo().definitionForWithoutExistenceAssert(type) == null;
+ DexProgramClass syntheticClass =
+ new DexProgramClass(
+ type,
+ null,
+ new SynthesizedOrigin("enum unboxing", EnumUnboxer.class),
+ ClassAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC),
+ appView.dexItemFactory().objectType,
+ DexTypeList.empty(),
+ null,
+ null,
+ Collections.emptyList(),
+ null,
+ Collections.emptyList(),
+ DexAnnotationSet.empty(),
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedMethod.EMPTY_ARRAY,
+ DexEncodedMethod.EMPTY_ARRAY,
+ appView.dexItemFactory().getSkipNameValidationForTesting(),
+ DexProgramClass::checksumFromType);
+ appBuilder.addSynthesizedClass(syntheticClass);
+ appView
+ .appInfo()
+ .addSynthesizedClass(
+ syntheticClass, appView.appInfo().getMainDexClasses().containsAnyOf(contexts));
+ return syntheticClass.type;
+ }
+
+ private DexType findDeterministicContextType(Set<DexProgramClass> contexts) {
+ DexType deterministicContext = null;
+ for (DexProgramClass context : contexts) {
+ if (deterministicContext == null) {
+ deterministicContext = context.type;
+ } else if (context.type.slowCompareTo(deterministicContext) < 0) {
+ deterministicContext = context.type;
+ }
+ }
+ return deterministicContext;
+ }
+ }
+}
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 a7b1576..3414861 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
@@ -254,8 +254,7 @@
cls.getKotlinInfo().isSyntheticClass()
&& cls.getKotlinInfo().asSyntheticClass().isLambda()
&& KotlinLambdaGroupIdFactory.hasValidAnnotations(kotlin, cls)
- && (appView.options().featureSplitConfiguration == null
- || !appView.options().featureSplitConfiguration.isInFeature(cls)))
+ && !appView.appInfo().getClassToFeatureSplitMap().isInFeature(cls))
.sorted((a, b) -> a.type.slowCompareTo(b.type)) // Ensure stable ordering.
.forEachOrdered(
lambda -> {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
index 0372a33..0231d43 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
@@ -15,7 +15,6 @@
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.ProgramMethod;
import com.android.tools.r8.graph.ResolutionResult;
@@ -38,7 +37,6 @@
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
@@ -132,23 +130,28 @@
DexType type = field.field.type;
if (singletonFields.put(type, field) != null) {
// There is already candidate singleton field found.
- notEligible.add(type);
+ markNotEligible(type, notEligible);
}
}
// Don't allow fields with this candidate types.
for (DexEncodedField field : cls.instanceFields()) {
- notEligible.add(field.field.type);
+ markNotEligible(field.field.type, notEligible);
}
// Don't allow methods that take a value of this type.
for (DexEncodedMethod method : cls.methods()) {
- DexProto proto = method.method.proto;
- notEligible.addAll(Arrays.asList(proto.parameters.values));
+ for (DexType parameter : method.getProto().parameters.values) {
+ markNotEligible(parameter, notEligible);
+ }
+ if (method.isSynchronized()) {
+ markNotEligible(cls.type, notEligible);
+ }
}
// High-level limitations on what classes we consider eligible.
- if (cls.isInterface() // Must not be an interface or an abstract class.
+ if (cls.isInterface()
+ // Must not be an interface or an abstract class.
|| cls.accessFlags.isAbstract()
// Don't support candidates with instance fields
|| cls.instanceFields().size() > 0
@@ -159,7 +162,7 @@
// Staticizing classes implementing interfaces is more
// difficult, so don't support it until we really need it.
|| !cls.interfaces.isEmpty()) {
- notEligible.add(cls.type);
+ markNotEligible(cls.type, notEligible);
}
});
@@ -180,6 +183,12 @@
});
}
+ private void markNotEligible(DexType type, Set<DexType> notEligible) {
+ if (type.isClassType()) {
+ notEligible.add(type);
+ }
+ }
+
private boolean isPinned(DexClass clazz, DexEncodedField singletonField) {
AppInfoWithLiveness appInfo = appView.appInfo();
if (appInfo.isPinned(clazz.type) || appInfo.isPinned(singletonField.field)) {
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index 477f516..012bd0e 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -2262,8 +2262,9 @@
}
LiveIntervalsUse firstUseWithLowerLimit = null;
boolean hasUsesBeforeFirstUseWithLowerLimit = false;
+ int highestRegisterNumber = registerNumber + spilled.requiredRegisters() - 1;
for (LiveIntervalsUse use : spilled.getUses()) {
- if (registerNumber > use.getLimit()) {
+ if (highestRegisterNumber > use.getLimit()) {
firstUseWithLowerLimit = use;
break;
} else {
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 ec34d75..e13331f 100644
--- a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
@@ -42,6 +42,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.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.ImmutableMap;
@@ -113,6 +114,7 @@
marker.isRelocator() ? Optional.empty() : Optional.of(marker.toString());
LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(appView);
for (DexProgramClass clazz : application.classes()) {
+ assert SyntheticItems.verifyNotInternalSynthetic(clazz.getType());
if (clazz.getSynthesizedFrom().isEmpty()
|| options.isDesugaredLibraryCompilation()
|| options.cfToCfDesugar) {
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 5163a17..848008c 100644
--- a/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
+++ b/src/main/java/com/android/tools/r8/repackaging/Repackaging.java
@@ -63,7 +63,7 @@
// For each package, find the set of classes that can be repackaged, and move them to the
// desired namespace.
Map<DexType, DexType> mappings = new IdentityHashMap<>();
- for (ProgramPackage pkg : ProgramPackageCollection.create(appView)) {
+ for (ProgramPackage pkg : ProgramPackageCollection.createWithAllProgramClasses(appView)) {
Iterable<DexProgramClass> classesToRepackage =
computeClassesToRepackage(pkg, executorService);
String newPackageDescriptor = getNewPackageDescriptor(pkg);
diff --git a/src/main/java/com/android/tools/r8/retrace/Retrace.java b/src/main/java/com/android/tools/r8/retrace/Retrace.java
index 8e65f12..f34a5aa 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -49,7 +49,7 @@
public static final String USAGE_MESSAGE =
StringUtils.lines(
- "Usage: retrace <proguard-map> <stacktrace-file> [--regex <regexp>, --verbose, --info]",
+ "Usage: retrace <proguard-map> [stack-trace-file] [--regex <regexp>, --verbose, --info]",
" where <proguard-map> is an r8 generated mapping file.");
private static Builder parseArguments(String[] args, DiagnosticsHandler diagnosticsHandler) {
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 6c6bab5..627d84f 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult.isOverriding;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexClass;
@@ -40,14 +41,13 @@
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.graph.SubtypingInfo;
-import com.android.tools.r8.graph.SyntheticItems;
-import com.android.tools.r8.graph.SyntheticItems.CommittedItems;
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.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;
import com.android.tools.r8.utils.ListUtils;
@@ -163,8 +163,11 @@
public final PredicateSet<DexType> alwaysClassInline;
/** All types that *must* never be inlined due to a configuration directive (testing only). */
public final Set<DexType> neverClassInline;
- /** All types that *must* never be merged due to a configuration directive (testing only). */
- public final Set<DexType> neverMerge;
+
+ private final Set<DexType> noVerticalClassMerging;
+ private final Set<DexType> noHorizontalClassMerging;
+ private final Set<DexType> noStaticClassMerging;
+
/** Set of const-class references. */
public final Set<DexType> constClassReferences;
/**
@@ -195,9 +198,9 @@
// TODO(zerny): Clean up the constructors so we have just one.
AppInfoWithLiveness(
- DirectMappedDexApplication application,
+ CommittedItems syntheticItems,
+ ClassToFeatureSplitMap classToFeatureSplitMap,
MainDexClasses mainDexClasses,
- SyntheticItems.CommittedItems syntheticItems,
Set<DexType> deadProtoTypes,
Set<DexType> missingTypes,
Set<DexType> liveTypes,
@@ -230,7 +233,9 @@
Set<DexMethod> neverReprocess,
PredicateSet<DexType> alwaysClassInline,
Set<DexType> neverClassInline,
- Set<DexType> neverMerge,
+ Set<DexType> noVerticalClassMerging,
+ Set<DexType> noHorizontalClassMerging,
+ Set<DexType> noStaticClassMerging,
Set<DexReference> neverPropagateValue,
Object2BooleanMap<DexReference> identifierNameStrings,
Set<DexType> prunedTypes,
@@ -238,7 +243,7 @@
EnumValueInfoMapCollection enumValueInfoMaps,
Set<DexType> constClassReferences,
Map<DexType, Visibility> initClassReferences) {
- super(application, mainDexClasses, syntheticItems);
+ super(syntheticItems, classToFeatureSplitMap, mainDexClasses);
this.deadProtoTypes = deadProtoTypes;
this.missingTypes = missingTypes;
this.liveTypes = liveTypes;
@@ -271,7 +276,9 @@
this.neverReprocess = neverReprocess;
this.alwaysClassInline = alwaysClassInline;
this.neverClassInline = neverClassInline;
- this.neverMerge = neverMerge;
+ this.noVerticalClassMerging = noVerticalClassMerging;
+ this.noHorizontalClassMerging = noHorizontalClassMerging;
+ this.noStaticClassMerging = noStaticClassMerging;
this.neverPropagateValue = neverPropagateValue;
this.identifierNameStrings = identifierNameStrings;
this.prunedTypes = prunedTypes;
@@ -315,7 +322,9 @@
Set<DexMethod> neverReprocess,
PredicateSet<DexType> alwaysClassInline,
Set<DexType> neverClassInline,
- Set<DexType> neverMerge,
+ Set<DexType> noVerticalClassMerging,
+ Set<DexType> noHorizontalClassMerging,
+ Set<DexType> noStaticClassMerging,
Set<DexReference> neverPropagateValue,
Object2BooleanMap<DexReference> identifierNameStrings,
Set<DexType> prunedTypes,
@@ -324,9 +333,9 @@
Set<DexType> constClassReferences,
Map<DexType, Visibility> initClassReferences) {
super(
- appInfoWithClassHierarchy.app(),
- appInfoWithClassHierarchy.getMainDexClasses(),
- appInfoWithClassHierarchy.getSyntheticItems().commit(appInfoWithClassHierarchy.app()));
+ appInfoWithClassHierarchy.getSyntheticItems().commit(appInfoWithClassHierarchy.app()),
+ appInfoWithClassHierarchy.getClassToFeatureSplitMap(),
+ appInfoWithClassHierarchy.getMainDexClasses());
this.deadProtoTypes = deadProtoTypes;
this.missingTypes = missingTypes;
this.liveTypes = liveTypes;
@@ -359,7 +368,9 @@
this.neverReprocess = neverReprocess;
this.alwaysClassInline = alwaysClassInline;
this.neverClassInline = neverClassInline;
- this.neverMerge = neverMerge;
+ this.noVerticalClassMerging = noVerticalClassMerging;
+ this.noHorizontalClassMerging = noHorizontalClassMerging;
+ this.noStaticClassMerging = noStaticClassMerging;
this.neverPropagateValue = neverPropagateValue;
this.identifierNameStrings = identifierNameStrings;
this.prunedTypes = prunedTypes;
@@ -369,12 +380,16 @@
this.initClassReferences = initClassReferences;
}
- private AppInfoWithLiveness(AppInfoWithLiveness previous) {
+ private AppInfoWithLiveness(
+ AppInfoWithLiveness previous, CommittedItems committedItems, Set<DexType> removedTypes) {
this(
- previous,
+ committedItems,
+ previous.getClassToFeatureSplitMap(),
+ previous.getMainDexClasses(),
previous.deadProtoTypes,
previous.missingTypes,
- previous.liveTypes,
+ CollectionUtils.mergeSets(
+ Sets.difference(previous.liveTypes, removedTypes), committedItems.getCommittedTypes()),
previous.instantiatedAppServices,
previous.targetedMethods,
previous.failedResolutionTargets,
@@ -404,7 +419,9 @@
previous.neverReprocess,
previous.alwaysClassInline,
previous.neverClassInline,
- previous.neverMerge,
+ previous.noVerticalClassMerging,
+ previous.noHorizontalClassMerging,
+ previous.noStaticClassMerging,
previous.neverPropagateValue,
previous.identifierNameStrings,
previous.prunedTypes,
@@ -417,15 +434,17 @@
private AppInfoWithLiveness(
AppInfoWithLiveness previous,
DirectMappedDexApplication application,
- Collection<DexType> removedClasses,
+ Set<DexType> removedClasses,
Collection<DexReference> additionalPinnedItems) {
this(
- application,
- previous.getMainDexClasses(),
- previous.getSyntheticItems().commit(application),
+ previous.getSyntheticItems().commitPrunedClasses(application, removedClasses),
+ previous.getClassToFeatureSplitMap().withoutPrunedClasses(removedClasses),
+ previous.getMainDexClasses().withoutPrunedClasses(removedClasses),
previous.deadProtoTypes,
previous.missingTypes,
- previous.liveTypes,
+ removedClasses == null
+ ? previous.liveTypes
+ : Sets.difference(previous.liveTypes, removedClasses),
previous.instantiatedAppServices,
previous.targetedMethods,
previous.failedResolutionTargets,
@@ -455,7 +474,9 @@
previous.neverReprocess,
previous.alwaysClassInline,
previous.neverClassInline,
- previous.neverMerge,
+ previous.noVerticalClassMerging,
+ previous.noHorizontalClassMerging,
+ previous.noStaticClassMerging,
previous.neverPropagateValue,
previous.identifierNameStrings,
removedClasses == null
@@ -510,9 +531,9 @@
Map<DexField, Int2ReferenceMap<DexField>> switchMaps,
EnumValueInfoMapCollection enumValueInfoMaps) {
super(
- previous.app(),
- previous.getMainDexClasses(),
- previous.getSyntheticItems().commit(previous.app()));
+ previous.getSyntheticItems().commit(previous.app()),
+ previous.getClassToFeatureSplitMap(),
+ previous.getMainDexClasses());
this.deadProtoTypes = previous.deadProtoTypes;
this.missingTypes = previous.missingTypes;
this.liveTypes = previous.liveTypes;
@@ -545,7 +566,9 @@
this.neverReprocess = previous.neverReprocess;
this.alwaysClassInline = previous.alwaysClassInline;
this.neverClassInline = previous.neverClassInline;
- this.neverMerge = previous.neverMerge;
+ this.noVerticalClassMerging = previous.noVerticalClassMerging;
+ this.noHorizontalClassMerging = previous.noHorizontalClassMerging;
+ this.noStaticClassMerging = previous.noStaticClassMerging;
this.neverPropagateValue = previous.neverPropagateValue;
this.identifierNameStrings = previous.identifierNameStrings;
this.prunedTypes = previous.prunedTypes;
@@ -570,8 +593,6 @@
|| InterfaceMethodRewriter.isCompanionClassType(type)
|| InterfaceMethodRewriter.hasDispatchClassSuffix(type)
|| InterfaceMethodRewriter.isEmulatedLibraryClassType(type)
- || type.toDescriptorString().startsWith("L$r8$backportedMethods$")
- || type.toDescriptorString().startsWith("Lj$/$r8$backportedMethods$")
|| type.toDescriptorString().startsWith("Lj$/$r8$retargetLibraryMember$")
|| TwrCloseResourceRewriter.isUtilityClassDescriptor(type)
// TODO(b/150736225): Not sure how to remove these.
@@ -956,7 +977,7 @@
*/
public AppInfoWithLiveness prunedCopyFrom(
DirectMappedDexApplication application,
- Collection<DexType> removedClasses,
+ Set<DexType> removedClasses,
Collection<DexReference> additionalPinnedItems) {
assert checkIfObsolete();
if (!removedClasses.isEmpty()) {
@@ -966,6 +987,11 @@
return new AppInfoWithLiveness(this, application, removedClasses, additionalPinnedItems);
}
+ public AppInfoWithLiveness rebuildWithLiveness(
+ CommittedItems committedItems, Set<DexType> removedTypes) {
+ return new AppInfoWithLiveness(this, committedItems, removedTypes);
+ }
+
public AppInfoWithLiveness rewrittenWithLens(
DirectMappedDexApplication application, NestedGraphLens lens) {
assert checkIfObsolete();
@@ -986,12 +1012,12 @@
.map(FieldResolutionResult::getResolvedField)
.collect(Collectors.toList()));
- CommittedItems committedItems = getSyntheticItems().commit(application, lens);
+ CommittedItems committedItems = getSyntheticItems().commitRewrittenWithLens(application, lens);
DexDefinitionSupplier definitionSupplier = application.getDefinitionsSupplier(committedItems);
return new AppInfoWithLiveness(
- application,
- getMainDexClasses().rewrittenWithLens(lens),
committedItems,
+ getClassToFeatureSplitMap().rewrittenWithLens(lens),
+ getMainDexClasses().rewrittenWithLens(lens),
deadProtoTypes,
missingTypes,
lens.rewriteTypes(liveTypes),
@@ -1028,7 +1054,9 @@
lens.rewriteMethods(neverReprocess),
alwaysClassInline.rewriteItems(lens::lookupType),
lens.rewriteTypes(neverClassInline),
- lens.rewriteTypes(neverMerge),
+ lens.rewriteTypes(noVerticalClassMerging),
+ lens.rewriteTypes(noHorizontalClassMerging),
+ lens.rewriteTypes(noStaticClassMerging),
lens.rewriteReferences(neverPropagateValue),
lens.rewriteReferenceKeys(identifierNameStrings),
// Don't rewrite pruned types - the removed types are identified by their original name.
@@ -1402,4 +1430,28 @@
this)
.shouldBreak();
}
+
+ /**
+ * All types that *must* never be merged vertically due to a configuration directive (testing
+ * only).
+ */
+ public Set<DexType> getNoVerticalClassMergingSet() {
+ return noVerticalClassMerging;
+ }
+
+ /**
+ * All types that *must* never be merged horizontally due to a configuration directive (testing
+ * only).
+ */
+ public Set<DexType> getNoHorizontalClassMergingSet() {
+ return noHorizontalClassMerging;
+ }
+
+ /**
+ * All types that *must* never be merged by the static class merger due to a configuration
+ * directive (testing only).
+ */
+ public Set<DexType> getNoStaticClassMergingSet() {
+ return noStaticClassMerging;
+ }
}
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 d692cef..98def17 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -2743,7 +2743,7 @@
}
public NestedGraphLens buildGraphLens(AppView<?> appView) {
- return lambdaRewriter != null ? lambdaRewriter.buildMappingLens(appView) : null;
+ return lambdaRewriter != null ? lambdaRewriter.fixup() : null;
}
private void keepClassWithRules(DexProgramClass clazz, Set<ProguardKeepRuleBase> rules) {
@@ -2885,7 +2885,7 @@
// Now all additions are computed, the application is atomically extended with those additions.
appInfo =
- appInfo.rebuild(
+ appInfo.rebuildWithClassHierarchy(
app -> {
Builder appBuilder = app.asDirect().builder();
additions.amendApplication(appBuilder);
@@ -3019,9 +3019,9 @@
AppInfoWithLiveness appInfoWithLiveness =
new AppInfoWithLiveness(
- app,
- appInfo.getMainDexClasses(),
appInfo.getSyntheticItems().commit(app),
+ appInfo.getClassToFeatureSplitMap(),
+ appInfo.getMainDexClasses(),
deadProtoTypes,
mode.isFinalTreeShaking()
? Sets.union(initialMissingTypes, missingTypes)
@@ -3059,7 +3059,9 @@
rootSet.neverReprocess,
rootSet.alwaysClassInline,
rootSet.neverClassInline,
- rootSet.neverMerge,
+ rootSet.noVerticalClassMerging,
+ rootSet.noHorizontalClassMerging,
+ rootSet.noStaticClassMerging,
rootSet.neverPropagateValue,
joinIdentifierNameStrings(rootSet.identifierNameStrings, identifierNameStrings),
Collections.emptySet(),
diff --git a/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java b/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
index 8841f15..18709f3 100644
--- a/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
+++ b/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
@@ -300,6 +300,13 @@
if (neverInlineRuleForCondition != null) {
rootSetBuilder.runPerRule(executorService, futures, neverInlineRuleForCondition, null);
}
+
+ // Prevent horizontal class merging of any -if rule members.
+ NoHorizontalClassMergingRule noHorizontalClassMergingRule =
+ materializedRule.noHorizontalClassMergingRuleForCondition(dexItemFactory);
+ if (noHorizontalClassMergingRule != null) {
+ rootSetBuilder.runPerRule(executorService, futures, noHorizontalClassMergingRule, null);
+ }
}
// Keep whatever is required by the -if rule.
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java b/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java
index cfadae32..67cd3b8 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java
@@ -83,6 +83,16 @@
return mainDexClasses.size();
}
+ public MainDexClasses withoutPrunedClasses(Set<DexType> prunedClasses) {
+ MainDexClasses mainDexClassesAfterPruning = createEmptyMainDexClasses();
+ for (DexType mainDexClass : mainDexClasses) {
+ if (!prunedClasses.contains(mainDexClass)) {
+ mainDexClassesAfterPruning.mainDexClasses.add(mainDexClass);
+ }
+ }
+ return mainDexClassesAfterPruning;
+ }
+
public static class Builder {
private final Set<DexType> mainDexClasses = Sets.newIdentityHashSet();
diff --git a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java b/src/main/java/com/android/tools/r8/shaking/NoHorizontalClassMergingRule.java
similarity index 65%
copy from src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
copy to src/main/java/com/android/tools/r8/shaking/NoHorizontalClassMergingRule.java
index ee57043..acaedac 100644
--- a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/NoHorizontalClassMergingRule.java
@@ -1,40 +1,32 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
+
package com.android.tools.r8.shaking;
-import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.position.Position;
import java.util.List;
-public class ClassMergingRule extends ProguardConfigurationRule {
+public class NoHorizontalClassMergingRule extends ProguardConfigurationRule {
- public enum Type {
- NEVER
- }
+ public static final String RULE_NAME = "nohorizontalclassmerging";
- public static class Builder extends ProguardConfigurationRule.Builder<ClassMergingRule, Builder> {
+ public static class Builder
+ extends ProguardConfigurationRule.Builder<NoHorizontalClassMergingRule, Builder> {
private Builder() {
super();
}
- Type type;
-
@Override
- public Builder self() {
- return this;
- }
-
- public Builder setType(Type type) {
- this.type = type;
+ public NoHorizontalClassMergingRule.Builder self() {
return this;
}
@Override
- public ClassMergingRule build() {
- return new ClassMergingRule(
+ public NoHorizontalClassMergingRule build() {
+ return new NoHorizontalClassMergingRule(
origin,
getPosition(),
source,
@@ -47,14 +39,11 @@
buildInheritanceAnnotations(),
inheritanceClassName,
inheritanceIsExtends,
- memberRules,
- type);
+ memberRules);
}
}
- private final Type type;
-
- private ClassMergingRule(
+ private NoHorizontalClassMergingRule(
Origin origin,
Position position,
String source,
@@ -67,8 +56,7 @@
List<ProguardTypeMatcher> inheritanceAnnotations,
ProguardTypeMatcher inheritanceClassName,
boolean inheritanceIsExtends,
- List<ProguardMemberRule> memberRules,
- Type type) {
+ List<ProguardMemberRule> memberRules) {
super(
origin,
position,
@@ -83,23 +71,14 @@
inheritanceClassName,
inheritanceIsExtends,
memberRules);
- this.type = type;
}
public static Builder builder() {
return new Builder();
}
- public Type getType() {
- return type;
- }
-
@Override
String typeString() {
- switch (type) {
- case NEVER:
- return "nevermerge";
- }
- throw new Unreachable("Unknown class merging type " + type);
+ return RULE_NAME;
}
}
diff --git a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java b/src/main/java/com/android/tools/r8/shaking/NoStaticClassMergingRule.java
similarity index 65%
copy from src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
copy to src/main/java/com/android/tools/r8/shaking/NoStaticClassMergingRule.java
index ee57043..dc19834 100644
--- a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/NoStaticClassMergingRule.java
@@ -1,40 +1,31 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
+
package com.android.tools.r8.shaking;
-import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.position.Position;
import java.util.List;
-public class ClassMergingRule extends ProguardConfigurationRule {
+public class NoStaticClassMergingRule extends ProguardConfigurationRule {
+ public static final String RULE_NAME = "nostaticclassmerging";
- public enum Type {
- NEVER
- }
-
- public static class Builder extends ProguardConfigurationRule.Builder<ClassMergingRule, Builder> {
+ public static class Builder
+ extends ProguardConfigurationRule.Builder<NoStaticClassMergingRule, Builder> {
private Builder() {
super();
}
- Type type;
-
@Override
- public Builder self() {
- return this;
- }
-
- public Builder setType(Type type) {
- this.type = type;
+ public NoStaticClassMergingRule.Builder self() {
return this;
}
@Override
- public ClassMergingRule build() {
- return new ClassMergingRule(
+ public NoStaticClassMergingRule build() {
+ return new NoStaticClassMergingRule(
origin,
getPosition(),
source,
@@ -47,14 +38,11 @@
buildInheritanceAnnotations(),
inheritanceClassName,
inheritanceIsExtends,
- memberRules,
- type);
+ memberRules);
}
}
- private final Type type;
-
- private ClassMergingRule(
+ private NoStaticClassMergingRule(
Origin origin,
Position position,
String source,
@@ -67,8 +55,7 @@
List<ProguardTypeMatcher> inheritanceAnnotations,
ProguardTypeMatcher inheritanceClassName,
boolean inheritanceIsExtends,
- List<ProguardMemberRule> memberRules,
- Type type) {
+ List<ProguardMemberRule> memberRules) {
super(
origin,
position,
@@ -83,23 +70,14 @@
inheritanceClassName,
inheritanceIsExtends,
memberRules);
- this.type = type;
}
public static Builder builder() {
return new Builder();
}
- public Type getType() {
- return type;
- }
-
@Override
String typeString() {
- switch (type) {
- case NEVER:
- return "nevermerge";
- }
- throw new Unreachable("Unknown class merging type " + type);
+ return RULE_NAME;
}
}
diff --git a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java b/src/main/java/com/android/tools/r8/shaking/NoVerticalClassMergingRule.java
similarity index 68%
rename from src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
rename to src/main/java/com/android/tools/r8/shaking/NoVerticalClassMergingRule.java
index ee57043..edda33c 100644
--- a/src/main/java/com/android/tools/r8/shaking/ClassMergingRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/NoVerticalClassMergingRule.java
@@ -3,38 +3,29 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking;
-import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.position.Position;
import java.util.List;
-public class ClassMergingRule extends ProguardConfigurationRule {
+public class NoVerticalClassMergingRule extends ProguardConfigurationRule {
- public enum Type {
- NEVER
- }
+ public static final String RULE_NAME = "noverticalclassmerging";
- public static class Builder extends ProguardConfigurationRule.Builder<ClassMergingRule, Builder> {
+ public static class Builder
+ extends ProguardConfigurationRule.Builder<NoVerticalClassMergingRule, Builder> {
private Builder() {
super();
}
- Type type;
-
@Override
public Builder self() {
return this;
}
- public Builder setType(Type type) {
- this.type = type;
- return this;
- }
-
@Override
- public ClassMergingRule build() {
- return new ClassMergingRule(
+ public NoVerticalClassMergingRule build() {
+ return new NoVerticalClassMergingRule(
origin,
getPosition(),
source,
@@ -47,14 +38,11 @@
buildInheritanceAnnotations(),
inheritanceClassName,
inheritanceIsExtends,
- memberRules,
- type);
+ memberRules);
}
}
- private final Type type;
-
- private ClassMergingRule(
+ private NoVerticalClassMergingRule(
Origin origin,
Position position,
String source,
@@ -67,8 +55,7 @@
List<ProguardTypeMatcher> inheritanceAnnotations,
ProguardTypeMatcher inheritanceClassName,
boolean inheritanceIsExtends,
- List<ProguardMemberRule> memberRules,
- Type type) {
+ List<ProguardMemberRule> memberRules) {
super(
origin,
position,
@@ -83,23 +70,14 @@
inheritanceClassName,
inheritanceIsExtends,
memberRules);
- this.type = type;
}
public static Builder builder() {
return new Builder();
}
- public Type getType() {
- return type;
- }
-
@Override
String typeString() {
- switch (type) {
- case NEVER:
- return "nevermerge";
- }
- throw new Unreachable("Unknown class merging type " + type);
+ return RULE_NAME;
}
}
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardClassSpecification.java b/src/main/java/com/android/tools/r8/shaking/ProguardClassSpecification.java
index 2bf270a..9269a2a 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardClassSpecification.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardClassSpecification.java
@@ -92,8 +92,9 @@
return inheritanceIsExtends;
}
- public void setInheritanceIsExtends(boolean inheritanceIsExtends) {
+ public B setInheritanceIsExtends(boolean inheritanceIsExtends) {
this.inheritanceIsExtends = inheritanceIsExtends;
+ return self();
}
public boolean hasInheritanceClassName() {
@@ -104,13 +105,15 @@
return inheritanceClassName;
}
- public void setInheritanceClassName(ProguardTypeMatcher inheritanceClassName) {
+ public B setInheritanceClassName(ProguardTypeMatcher inheritanceClassName) {
this.inheritanceClassName = inheritanceClassName;
+ return self();
}
- public void addInheritanceAnnotations(List<ProguardTypeMatcher> inheritanceAnnotations) {
+ public B addInheritanceAnnotations(List<ProguardTypeMatcher> inheritanceAnnotations) {
assert inheritanceAnnotations != null;
this.inheritanceAnnotations.addAll(inheritanceAnnotations);
+ return self();
}
public List<ProguardTypeMatcher> buildInheritanceAnnotations() {
@@ -139,33 +142,38 @@
return classTypeNegated;
}
- public void setClassTypeNegated(boolean classTypeNegated) {
+ public B setClassTypeNegated(boolean classTypeNegated) {
this.classTypeNegated = classTypeNegated;
+ return self();
}
public ProguardAccessFlags getClassAccessFlags() {
return classAccessFlags;
}
- public void setClassAccessFlags(ProguardAccessFlags flags) {
+ public B setClassAccessFlags(ProguardAccessFlags flags) {
classAccessFlags = flags;
+ return self();
}
public ProguardAccessFlags getNegatedClassAccessFlags() {
return negatedClassAccessFlags;
}
- public void setNegatedClassAccessFlags(ProguardAccessFlags flags) {
+ public B setNegatedClassAccessFlags(ProguardAccessFlags flags) {
negatedClassAccessFlags = flags;
+ return self();
}
- public void addClassAnnotation(ProguardTypeMatcher classAnnotation) {
+ public B addClassAnnotation(ProguardTypeMatcher classAnnotation) {
classAnnotations.add(classAnnotation);
+ return self();
}
- public void addClassAnnotations(List<ProguardTypeMatcher> classAnnotations) {
+ public B addClassAnnotations(List<ProguardTypeMatcher> classAnnotations) {
assert classAnnotations != null;
this.classAnnotations.addAll(classAnnotations);
+ return self();
}
public List<ProguardTypeMatcher> buildClassAnnotations() {
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 6b5604e..d846f49 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -302,9 +302,9 @@
parseClassFilter(configurationBuilder::addDontWarnPattern);
} else if (acceptString("dontnote")) {
parseClassFilter(configurationBuilder::addDontNotePattern);
- } else if (acceptString("repackageclasses")) {
+ } else if (acceptString(REPACKAGE_CLASSES)) {
if (configurationBuilder.getPackageObfuscationMode() == PackageObfuscationMode.FLATTEN) {
- warnOverridingOptions("repackageclasses", "flattenpackagehierarchy", optionStart);
+ warnOverridingOptions(REPACKAGE_CLASSES, FLATTEN_PACKAGE_HIERARCHY, optionStart);
}
skipWhitespace();
char quote = acceptQuoteIfPresent();
@@ -318,9 +318,9 @@
configurationBuilder.setPackagePrefix(parsePackageNameOrEmptyString());
}
}
- } else if (acceptString("flattenpackagehierarchy")) {
+ } else if (acceptString(FLATTEN_PACKAGE_HIERARCHY)) {
if (configurationBuilder.getPackageObfuscationMode() == PackageObfuscationMode.REPACKAGE) {
- warnOverridingOptions("repackageclasses", "flattenpackagehierarchy", optionStart);
+ warnOverridingOptions(REPACKAGE_CLASSES, FLATTEN_PACKAGE_HIERARCHY, optionStart);
skipWhitespace();
if (isOptionalArgumentGiven()) {
skipSingleArgument();
@@ -469,8 +469,18 @@
configurationBuilder.addRule(rule);
return true;
}
- if (acceptString("nevermerge")) {
- ClassMergingRule rule = parseClassMergingRule(ClassMergingRule.Type.NEVER, optionStart);
+ if (acceptString(NoVerticalClassMergingRule.RULE_NAME)) {
+ ProguardConfigurationRule rule = parseNoVerticalClassMergingRule(optionStart);
+ configurationBuilder.addRule(rule);
+ return true;
+ }
+ if (acceptString(NoHorizontalClassMergingRule.RULE_NAME)) {
+ ProguardConfigurationRule rule = parseNoHorizontalClassMergingRule(optionStart);
+ configurationBuilder.addRule(rule);
+ return true;
+ }
+ if (acceptString(NoStaticClassMergingRule.RULE_NAME)) {
+ ProguardConfigurationRule rule = parseNoStaticClassMergingRule(optionStart);
configurationBuilder.addRule(rule);
return true;
}
@@ -741,10 +751,32 @@
return keepRuleBuilder.build();
}
- private ClassMergingRule parseClassMergingRule(ClassMergingRule.Type type, Position start)
+ private NoVerticalClassMergingRule parseNoVerticalClassMergingRule(Position start)
throws ProguardRuleParserException {
- ClassMergingRule.Builder keepRuleBuilder =
- ClassMergingRule.builder().setOrigin(origin).setStart(start).setType(type);
+ NoVerticalClassMergingRule.Builder keepRuleBuilder =
+ NoVerticalClassMergingRule.builder().setOrigin(origin).setStart(start);
+ parseClassSpec(keepRuleBuilder, false);
+ Position end = getPosition();
+ keepRuleBuilder.setSource(getSourceSnippet(contents, start, end));
+ keepRuleBuilder.setEnd(end);
+ return keepRuleBuilder.build();
+ }
+
+ private NoHorizontalClassMergingRule parseNoHorizontalClassMergingRule(Position start)
+ throws ProguardRuleParserException {
+ NoHorizontalClassMergingRule.Builder keepRuleBuilder =
+ NoHorizontalClassMergingRule.builder().setOrigin(origin).setStart(start);
+ parseClassSpec(keepRuleBuilder, false);
+ Position end = getPosition();
+ keepRuleBuilder.setSource(getSourceSnippet(contents, start, end));
+ keepRuleBuilder.setEnd(end);
+ return keepRuleBuilder.build();
+ }
+
+ private NoStaticClassMergingRule parseNoStaticClassMergingRule(Position start)
+ throws ProguardRuleParserException {
+ NoStaticClassMergingRule.Builder keepRuleBuilder =
+ NoStaticClassMergingRule.builder().setOrigin(origin).setStart(start);
parseClassSpec(keepRuleBuilder, false);
Position end = getPosition();
keepRuleBuilder.setSource(getSourceSnippet(contents, start, end));
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
index c8e185f..8313325 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
@@ -15,7 +15,7 @@
public class ProguardIfRule extends ProguardKeepRuleBase {
- private static final Origin neverInlineOrigin =
+ private static final Origin NEVER_INLINE_ORIGIN =
new Origin(Origin.root()) {
@Override
public String part() {
@@ -23,6 +23,14 @@
}
};
+ private static final Origin NO_HORIZONTAL_CLASS_MERGING_ORIGIN =
+ new Origin(Origin.root()) {
+ @Override
+ public String part() {
+ return "<SYNTHETIC_NO_HORIZONTAL_CLASS_MERGING_RULE>";
+ }
+ };
+
private final Set<DexReference> preconditions;
final ProguardKeepRule subsequentRule;
@@ -156,7 +164,7 @@
protected ClassInlineRule neverClassInlineRuleForCondition(DexItemFactory dexItemFactory) {
return new ClassInlineRule(
- neverInlineOrigin,
+ NEVER_INLINE_ORIGIN,
Position.UNKNOWN,
null,
ProguardTypeMatcher.materializeList(getClassAnnotations(), dexItemFactory),
@@ -201,7 +209,7 @@
return null;
}
return new InlineRule(
- neverInlineOrigin,
+ NEVER_INLINE_ORIGIN,
Position.UNKNOWN,
null,
ProguardTypeMatcher.materializeList(getClassAnnotations(), dexItemFactory),
@@ -222,6 +230,37 @@
InlineRule.Type.NEVER);
}
+ protected NoHorizontalClassMergingRule noHorizontalClassMergingRuleForCondition(
+ DexItemFactory dexItemFactory) {
+ List<ProguardMemberRule> memberRules = null;
+ if (getMemberRules() != null) {
+ memberRules =
+ getMemberRules().stream()
+ .filter(rule -> rule.getRuleType().includesMethods())
+ .map(memberRule -> memberRule.materialize(dexItemFactory))
+ .collect(Collectors.toList());
+ }
+
+ return NoHorizontalClassMergingRule.builder()
+ .setOrigin(NO_HORIZONTAL_CLASS_MERGING_ORIGIN)
+ .addClassAnnotations(
+ ProguardTypeMatcher.materializeList(getClassAnnotations(), dexItemFactory))
+ .setClassAccessFlags(getClassAccessFlags())
+ .setNegatedClassAccessFlags(getNegatedClassAccessFlags())
+ .setClassType(getClassType())
+ .setClassTypeNegated(getClassTypeNegated())
+ .setClassNames(getClassNames().materialize(dexItemFactory))
+ .addInheritanceAnnotations(
+ ProguardTypeMatcher.materializeList(getInheritanceAnnotations(), dexItemFactory))
+ .setInheritanceClassName(
+ getInheritanceClassName() == null
+ ? null
+ : getInheritanceClassName().materialize(dexItemFactory))
+ .setInheritanceIsExtends(getInheritanceIsExtends())
+ .setMemberRules(memberRules)
+ .build();
+ }
+
@Override
public boolean equals(Object o) {
if (!(o instanceof ProguardIfRule)) {
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 db43676..f8b5987 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -97,7 +97,9 @@
private final Set<DexMethod> neverReprocess = Sets.newIdentityHashSet();
private final PredicateSet<DexType> alwaysClassInline = new PredicateSet<>();
private final Set<DexType> neverClassInline = Sets.newIdentityHashSet();
- private final Set<DexType> neverMerge = Sets.newIdentityHashSet();
+ private final Set<DexType> noVerticalClassMerging = Sets.newIdentityHashSet();
+ private final Set<DexType> noHorizontalClassMerging = Sets.newIdentityHashSet();
+ private final Set<DexType> noStaticClassMerging = Sets.newIdentityHashSet();
private final Set<DexReference> neverPropagateValue = Sets.newIdentityHashSet();
private final Map<DexReference, MutableItemsWithRules> dependentNoShrinking =
new IdentityHashMap<>();
@@ -240,7 +242,9 @@
|| rule instanceof WhyAreYouNotInliningRule) {
markMatchingMethods(clazz, memberKeepRules, rule, null, ifRule);
} else if (rule instanceof ClassInlineRule
- || rule instanceof ClassMergingRule
+ || rule instanceof NoVerticalClassMergingRule
+ || rule instanceof NoHorizontalClassMergingRule
+ || rule instanceof NoStaticClassMergingRule
|| rule instanceof ReprocessClassInitializerRule) {
if (allRulesSatisfied(memberKeepRules, clazz)) {
markClass(clazz, rule, ifRule);
@@ -318,7 +322,9 @@
appView,
subtypingInfo,
alwaysClassInline,
- neverMerge,
+ noVerticalClassMerging,
+ noHorizontalClassMerging,
+ noStaticClassMerging,
alwaysInline,
bypassClinitforInlining);
}
@@ -342,7 +348,9 @@
neverReprocess,
alwaysClassInline,
neverClassInline,
- neverMerge,
+ noVerticalClassMerging,
+ noHorizontalClassMerging,
+ noStaticClassMerging,
neverPropagateValue,
mayHaveSideEffects,
noSideEffects,
@@ -1204,16 +1212,14 @@
throw new Unreachable();
}
context.markAsUsed();
- } else if (context instanceof ClassMergingRule) {
- switch (((ClassMergingRule) context).getType()) {
- case NEVER:
- if (item.isDexClass()) {
- neverMerge.add(item.asDexClass().type);
- }
- break;
- default:
- throw new Unreachable();
- }
+ } else if (context instanceof NoVerticalClassMergingRule) {
+ noVerticalClassMerging.add(item.asDexClass().type);
+ context.markAsUsed();
+ } else if (context instanceof NoHorizontalClassMergingRule) {
+ noHorizontalClassMerging.add(item.asDexClass().type);
+ context.markAsUsed();
+ } else if (context instanceof NoStaticClassMergingRule) {
+ noStaticClassMerging.add(item.asDexClass().type);
context.markAsUsed();
} else if (context instanceof MemberValuePropagationRule) {
switch (((MemberValuePropagationRule) context).getType()) {
@@ -1734,7 +1740,9 @@
public final Set<DexMethod> reprocess;
public final Set<DexMethod> neverReprocess;
public final PredicateSet<DexType> alwaysClassInline;
- public final Set<DexType> neverMerge;
+ public final Set<DexType> noVerticalClassMerging;
+ public final Set<DexType> noHorizontalClassMerging;
+ public final Set<DexType> noStaticClassMerging;
public final Set<DexReference> neverPropagateValue;
public final Map<DexReference, ProguardMemberRule> mayHaveSideEffects;
public final Map<DexReference, ProguardMemberRule> noSideEffects;
@@ -1758,7 +1766,9 @@
Set<DexMethod> neverReprocess,
PredicateSet<DexType> alwaysClassInline,
Set<DexType> neverClassInline,
- Set<DexType> neverMerge,
+ Set<DexType> noVerticalClassMerging,
+ Set<DexType> noHorizontalClassMerging,
+ Set<DexType> noStaticClassMerging,
Set<DexReference> neverPropagateValue,
Map<DexReference, ProguardMemberRule> mayHaveSideEffects,
Map<DexReference, ProguardMemberRule> noSideEffects,
@@ -1787,7 +1797,9 @@
this.reprocess = reprocess;
this.neverReprocess = neverReprocess;
this.alwaysClassInline = alwaysClassInline;
- this.neverMerge = neverMerge;
+ this.noVerticalClassMerging = noVerticalClassMerging;
+ this.noHorizontalClassMerging = noHorizontalClassMerging;
+ this.noStaticClassMerging = noStaticClassMerging;
this.neverPropagateValue = neverPropagateValue;
this.mayHaveSideEffects = mayHaveSideEffects;
this.noSideEffects = noSideEffects;
@@ -1859,7 +1871,9 @@
}
public void pruneDeadItems(DexDefinitionSupplier definitions, Enqueuer enqueuer) {
- pruneDeadReferences(neverMerge, definitions, enqueuer);
+ pruneDeadReferences(noVerticalClassMerging, definitions, enqueuer);
+ pruneDeadReferences(noHorizontalClassMerging, definitions, enqueuer);
+ pruneDeadReferences(noStaticClassMerging, definitions, enqueuer);
pruneDeadReferences(alwaysInline, definitions, enqueuer);
pruneDeadReferences(noSideEffects.keySet(), definitions, enqueuer);
}
diff --git a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
index 3725f5f..abd2a99 100644
--- a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.shaking;
import com.android.tools.r8.FeatureSplit;
-import com.android.tools.r8.features.FeatureSplitConfiguration;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -243,12 +243,12 @@
return null;
}
- private FeatureSplitConfiguration getFeatureSplitConfiguration() {
- return appView.options().featureSplitConfiguration;
+ private ClassToFeatureSplitMap getClassToFeatureSplitMap() {
+ return appView.appInfo().getClassToFeatureSplitMap();
}
private MergeGroup getMergeGroup(DexProgramClass clazz) {
- if (appView.appInfo().neverMerge.contains(clazz.type)) {
+ if (appView.appInfo().getNoStaticClassMergingSet().contains(clazz.type)) {
return MergeGroup.DONT_MERGE;
}
if (clazz.staticFields().size() + clazz.getMethodCollection().size() == 0) {
@@ -303,13 +303,8 @@
}
private MergeKey getMergeKey(DexProgramClass clazz, MergeGroup mergeGroup) {
- FeatureSplitConfiguration featureSplitConfiguration = getFeatureSplitConfiguration();
- FeatureSplit featureSplit =
- featureSplitConfiguration != null
- ? featureSplitConfiguration.getFeatureSplit(clazz)
- : FeatureSplit.BASE;
return new MergeKey(
- featureSplit,
+ getClassToFeatureSplitMap().getFeatureSplit(clazz),
mergeGroup,
mayMergeAcrossPackageBoundaries(clazz)
? MergeKey.GLOBAL
@@ -452,8 +447,7 @@
assert targetClass.accessFlags.isAtLeastAsVisibleAs(sourceClass.accessFlags);
assert sourceClass.instanceFields().isEmpty();
assert targetClass.instanceFields().isEmpty();
- assert getFeatureSplitConfiguration() == null
- || getFeatureSplitConfiguration().inSameFeatureOrBothInBase(sourceClass, targetClass);
+ assert getClassToFeatureSplitMap().isInSameFeatureOrBothInBase(sourceClass, targetClass);
numberOfMergedClasses++;
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 5231fe6..6db253e 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -110,12 +110,7 @@
Log.debug(getClass(), "Removing class: " + clazz);
}
prunedTypes.add(clazz.type);
- // TODO(b/150118654): It would be nice to add something such as
- // clazz.type.isD8R8SynthesizedType, but such test is currently expensive since it is
- // based on strings, so we check only against the enum unboxing utility class.
- if (clazz.type != appView.dexItemFactory().enumUnboxingUtilityType) {
- unusedItemsPrinter.registerUnusedClass(clazz);
- }
+ unusedItemsPrinter.registerUnusedClass(clazz);
}
}
unusedItemsPrinter.finished();
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 2d21927..5948028 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -8,7 +8,6 @@
import static com.android.tools.r8.ir.code.Invoke.Type.STATIC;
import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.features.FeatureSplitConfiguration;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.Code;
@@ -350,7 +349,7 @@
|| allocationInfo.isImmediateInterfaceOfInstantiatedLambda(sourceClass)
|| appInfo.isPinned(sourceClass.type)
|| pinnedTypes.contains(sourceClass.type)
- || appInfo.neverMerge.contains(sourceClass.type)) {
+ || appInfo.getNoVerticalClassMergingSet().contains(sourceClass.type)) {
return false;
}
@@ -358,10 +357,9 @@
.map(DexEncodedMember::toReference)
.noneMatch(appInfo::isPinned);
- FeatureSplitConfiguration featureSplitConfiguration =
- appView.options().featureSplitConfiguration;
- if (featureSplitConfiguration != null
- && !featureSplitConfiguration.inSameFeatureOrBothInBase(sourceClass, targetClass)) {
+ if (!appInfo
+ .getClassToFeatureSplitMap()
+ .isInSameFeatureOrBothInBase(sourceClass, targetClass)) {
return false;
}
if (appView.appServices().allServiceTypes().contains(sourceClass.type)
diff --git a/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
new file mode 100644
index 0000000..f6a6245
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/CommittedItems.java
@@ -0,0 +1,75 @@
+// 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.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;
+
+/**
+ * Represents an application with a fully "committed" addition of synthetic items.
+ *
+ * <p>The committed application is used to rebuild application info (see AppInfo and its
+ * derivatives) with the associated additional information for the program at well defined points on
+ * the main thread.
+ *
+ * <p>A committed application will have no pending synthetics that are not defined in the program
+ * classes collection, and it must also satisfy that all synthetic types are indeed contained in the
+ * applications program class collection.
+ */
+public class CommittedItems implements SyntheticDefinitionsProvider {
+
+ // 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;
+
+ CommittedItems(
+ int nextSyntheticId,
+ DexApplication application,
+ ImmutableSet<DexType> legacySyntheticTypes,
+ ImmutableMap<DexType, SyntheticReference> syntheticItems,
+ ImmutableList<DexType> committedTypes) {
+ assert verifyTypesAreInApp(application, legacySyntheticTypes);
+ assert verifyTypesAreInApp(application, syntheticItems.keySet());
+ this.nextSyntheticId = nextSyntheticId;
+ this.application = application;
+ this.legacySyntheticTypes = legacySyntheticTypes;
+ this.syntheticItems = syntheticItems;
+ this.committedTypes = committedTypes;
+ }
+
+ // Conversion to a mutable synthetic items collection. Should only be used in AppInfo creation.
+ public SyntheticItems toSyntheticItems() {
+ return new SyntheticItems(this);
+ }
+
+ public DexApplication getApplication() {
+ return application;
+ }
+
+ public Collection<DexType> getCommittedTypes() {
+ return committedTypes;
+ }
+
+ @Override
+ public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
+ // 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/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
new file mode 100644
index 0000000..c03022e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -0,0 +1,36 @@
+// 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.DexType;
+import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.origin.Origin;
+
+/**
+ * A synthesizing context is the input type and origin that gives rise to a synthetic item.
+ *
+ * <p>Note that a context can only itself be a synthetic item if it was provided as an input that
+ * was marked as synthetic already, in which case it is its own context. In other words,
+ *
+ * <pre>
+ * for any synthetic item, I:
+ * context(I) == holder(I) iff I is a synthetic input
+ * </pre>
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SynthesizingContext {
+ final DexType type;
+ final Origin origin;
+
+ SynthesizingContext(DexType type, Origin origin) {
+ this.type = type;
+ this.origin = origin;
+ }
+
+ SynthesizingContext rewrite(NestedGraphLens lens) {
+ DexType rewritten = lens.lookupType(type);
+ return rewritten == type ? this : new SynthesizingContext(type, origin);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
new file mode 100644
index 0000000..ad04a8d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassBuilder.java
@@ -0,0 +1,117 @@
+// 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.DexAnnotationSet;
+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;
+import com.android.tools.r8.graph.EnclosingMethodAttribute;
+import com.android.tools.r8.graph.InnerClassAttribute;
+import com.android.tools.r8.graph.NestHostClassAttribute;
+import com.android.tools.r8.graph.NestMemberClassAttribute;
+import com.android.tools.r8.origin.Origin;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+public class SyntheticClassBuilder {
+ private final DexItemFactory factory;
+
+ private final DexType type;
+ private final Origin origin;
+
+ private DexType superType;
+ private DexTypeList interfaces = DexTypeList.empty();
+
+ private int nextMethodId = 0;
+ private List<SyntheticMethodBuilder> methods = new ArrayList<>();
+
+ SyntheticClassBuilder(DexType type, SynthesizingContext context, DexItemFactory factory) {
+ this.factory = factory;
+ this.type = type;
+ this.origin = context.origin;
+ this.superType = factory.objectType;
+ }
+
+ public DexItemFactory getFactory() {
+ return factory;
+ }
+
+ public DexType getType() {
+ return type;
+ }
+
+ private String getNextMethodName() {
+ return SyntheticItems.INTERNAL_SYNTHETIC_METHOD_PREFIX + nextMethodId++;
+ }
+
+ public SyntheticClassBuilder addMethod(Consumer<SyntheticMethodBuilder> fn) {
+ SyntheticMethodBuilder method = new SyntheticMethodBuilder(this, getNextMethodName());
+ fn.accept(method);
+ methods.add(method);
+ return this;
+ }
+
+ DexProgramClass build() {
+ ClassAccessFlags accessFlags =
+ ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
+ Kind originKind = null;
+ DexString sourceFile = null;
+ NestHostClassAttribute nestHost = null;
+ List<NestMemberClassAttribute> nestMembers = Collections.emptyList();
+ EnclosingMethodAttribute enclosingMembers = null;
+ List<InnerClassAttribute> innerClasses = Collections.emptyList();
+ DexAnnotationSet classAnnotations = DexAnnotationSet.empty();
+ 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);
+ } else {
+ directs.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,
+ classAnnotations,
+ staticFields,
+ instanceFields,
+ directMethods,
+ virtualMethods,
+ factory.getSkipNameValidationForTesting(),
+ c -> checksum);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
new file mode 100644
index 0000000..daf936d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.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.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.origin.Origin;
+import com.google.common.hash.HashCode;
+
+/**
+ * Base type for the defintion of a synthetic item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+abstract class SyntheticDefinition {
+ private final SynthesizingContext context;
+
+ SyntheticDefinition(SynthesizingContext context) {
+ this.context = context;
+ }
+
+ abstract SyntheticReference toReference();
+
+ SynthesizingContext getContext() {
+ return context;
+ }
+
+ DexType getContextType() {
+ return context.type;
+ }
+
+ Origin getContextOrigin() {
+ return context.origin;
+ }
+
+ abstract DexProgramClass getHolder();
+
+ abstract HashCode computeHash();
+
+ abstract boolean isEquivalentTo(SyntheticDefinition other);
+}
diff --git a/src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinitionsProvider.java
similarity index 75%
rename from src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java
rename to src/main/java/com/android/tools/r8/synthesis/SyntheticDefinitionsProvider.java
index 82e37ab..e66401e 100644
--- a/src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinitionsProvider.java
@@ -1,8 +1,10 @@
// 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;
+package com.android.tools.r8.synthesis;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
import java.util.function.Function;
public interface SyntheticDefinitionsProvider {
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
new file mode 100644
index 0000000..a2dd07e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -0,0 +1,364 @@
+// 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.AppView;
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexApplication;
+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.graph.GraphLens;
+import com.android.tools.r8.graph.GraphLens.Builder;
+import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.ArrayListMultimap;
+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.hash.HashCode;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.function.Predicate;
+
+public class SyntheticFinalization {
+
+ public static class Result {
+ public final CommittedItems commit;
+ public final ImmutableSet<DexType> removedSyntheticClasses;
+
+ public Result(CommittedItems commit, ImmutableSet<DexType> removedSyntheticClasses) {
+ this.commit = commit;
+ this.removedSyntheticClasses = removedSyntheticClasses;
+ }
+ }
+
+ private static class EquivalenceGroup<T extends SyntheticDefinition & Comparable<T>>
+ implements Comparable<EquivalenceGroup<T>> {
+ private List<T> members;
+
+ EquivalenceGroup(T singleton) {
+ this(singleton, Collections.singletonList(singleton));
+ }
+
+ EquivalenceGroup(T representative, List<T> members) {
+ assert !members.isEmpty();
+ assert members.get(0) == representative;
+ this.members = members;
+ }
+
+ T getRepresentative() {
+ return members.get(0);
+ }
+
+ public List<T> getMembers() {
+ return members;
+ }
+
+ @Override
+ public int compareTo(EquivalenceGroup<T> other) {
+ return getRepresentative().compareTo(other.getRepresentative());
+ }
+ }
+
+ private final InternalOptions options;
+ private final ImmutableSet<DexType> legacySyntheticTypes;
+ private final ImmutableMap<DexType, SyntheticReference> syntheticItems;
+
+ SyntheticFinalization(
+ InternalOptions options,
+ ImmutableSet<DexType> legacySyntheticTypes,
+ ImmutableMap<DexType, SyntheticReference> syntheticItems) {
+ this.options = options;
+ this.legacySyntheticTypes = legacySyntheticTypes;
+ this.syntheticItems = syntheticItems;
+ }
+
+ public Result computeFinalSynthetics(AppView<?> appView) {
+ assert verifyNoNestedSynthetics();
+ DexApplication application = appView.appInfo().app();
+ MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
+ GraphLens graphLens = appView.graphLens();
+
+ List<SyntheticMethodDefinition> methodDefinitions =
+ lookupSyntheticMethodDefinitions(application);
+
+ Map<HashCode, List<SyntheticMethodDefinition>> potentialEquivalences =
+ computePotentialEquivalences(methodDefinitions);
+
+ Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> equivalences =
+ computeActualEquivalences(potentialEquivalences, options.itemFactory);
+
+ Builder lensBuilder = GraphLens.builder();
+ List<DexProgramClass> newProgramClasses = new ArrayList<>();
+ List<DexProgramClass> finalSyntheticClasses = new ArrayList<>();
+ buildLensAndProgram(
+ application,
+ equivalences,
+ syntheticItems::containsKey,
+ mainDexClasses,
+ lensBuilder,
+ options.itemFactory,
+ newProgramClasses,
+ finalSyntheticClasses);
+
+ newProgramClasses.addAll(finalSyntheticClasses);
+
+ handleSynthesizedClassMapping(finalSyntheticClasses, application, options, mainDexClasses);
+
+ DexApplication app = application.builder().replaceProgramClasses(newProgramClasses).build();
+
+ appView.setGraphLens(lensBuilder.build(options.itemFactory, graphLens));
+ assert appView.appInfo().getMainDexClasses() == mainDexClasses;
+ return new Result(
+ new CommittedItems(
+ SyntheticItems.INVALID_ID_AFTER_SYNTHETIC_FINALIZATION,
+ app,
+ legacySyntheticTypes,
+ ImmutableMap.of(),
+ ImmutableList.of()),
+ syntheticItems.keySet());
+ }
+
+ private boolean verifyNoNestedSynthetics() {
+ for (SyntheticReference item : syntheticItems.values()) {
+ // Check that a context is never a synthetic unless it is an input, thus its own context.
+ assert item.getHolder() == item.getContextType()
+ || !syntheticItems.containsKey(item.getContextType());
+ }
+ return true;
+ }
+
+ private void handleSynthesizedClassMapping(
+ List<DexProgramClass> finalSyntheticClasses,
+ DexApplication application,
+ InternalOptions options,
+ MainDexClasses mainDexClasses) {
+ if (options.intermediate) {
+ updateSynthesizedClassMapping(application, finalSyntheticClasses);
+ }
+ updateMainDexListWithSynthesizedClassMap(application, mainDexClasses);
+ if (!options.intermediate) {
+ clearSynthesizedClassMapping(application);
+ }
+ }
+
+ private void updateSynthesizedClassMapping(
+ DexApplication application, List<DexProgramClass> finalSyntheticClasses) {
+ ListMultimap<DexProgramClass, DexProgramClass> originalToSynthesized =
+ ArrayListMultimap.create();
+ for (DexType type : legacySyntheticTypes) {
+ DexProgramClass clazz = DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
+ if (clazz != null) {
+ for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
+ originalToSynthesized.put(origin, clazz);
+ }
+ }
+ }
+ for (DexProgramClass clazz : finalSyntheticClasses) {
+ for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
+ originalToSynthesized.put(origin, clazz);
+ }
+ }
+ for (Map.Entry<DexProgramClass, Collection<DexProgramClass>> entry :
+ originalToSynthesized.asMap().entrySet()) {
+ DexProgramClass original = entry.getKey();
+ // Use a tree set to make sure that we have an ordering on the types.
+ // These types are put in an array in annotations in the output and we
+ // need a consistent ordering on them.
+ TreeSet<DexType> synthesized = new TreeSet<>(DexType::slowCompareTo);
+ entry.getValue().stream()
+ .map(dexProgramClass -> dexProgramClass.type)
+ .forEach(synthesized::add);
+ synthesized.addAll(
+ DexAnnotation.readAnnotationSynthesizedClassMap(original, application.dexItemFactory));
+
+ DexAnnotation updatedAnnotation =
+ DexAnnotation.createAnnotationSynthesizedClassMap(
+ synthesized, application.dexItemFactory);
+
+ original.setAnnotations(original.annotations().getWithAddedOrReplaced(updatedAnnotation));
+ }
+ }
+
+ private void updateMainDexListWithSynthesizedClassMap(
+ DexApplication application, MainDexClasses mainDexClasses) {
+ if (mainDexClasses.isEmpty()) {
+ return;
+ }
+ List<DexProgramClass> newMainDexClasses = new ArrayList<>();
+ mainDexClasses.forEach(
+ dexType -> {
+ DexProgramClass programClass =
+ DexProgramClass.asProgramClassOrNull(application.definitionFor(dexType));
+ if (programClass != null) {
+ Collection<DexType> derived =
+ DexAnnotation.readAnnotationSynthesizedClassMap(
+ programClass, application.dexItemFactory);
+ for (DexType type : derived) {
+ DexProgramClass syntheticClass =
+ DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
+ if (syntheticClass != null) {
+ newMainDexClasses.add(syntheticClass);
+ }
+ }
+ }
+ });
+ mainDexClasses.addAll(newMainDexClasses);
+ }
+
+ private void clearSynthesizedClassMapping(DexApplication application) {
+ for (DexProgramClass clazz : application.classes()) {
+ clazz.setAnnotations(
+ clazz.annotations().getWithout(application.dexItemFactory.annotationSynthesizedClassMap));
+ }
+ }
+
+ private static void buildLensAndProgram(
+ DexApplication app,
+ Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> syntheticMethodGroups,
+ Predicate<DexType> isSyntheticType,
+ MainDexClasses mainDexClasses,
+ Builder lensBuilder,
+ DexItemFactory factory,
+ List<DexProgramClass> normalClasses,
+ List<DexProgramClass> newSyntheticClasses) {
+
+ for (DexProgramClass clazz : app.classes()) {
+ if (!isSyntheticType.test(clazz.type)) {
+ normalClasses.add(clazz);
+ }
+ }
+
+ syntheticMethodGroups.forEach(
+ (syntheticType, syntheticGroup) -> {
+ SyntheticMethodDefinition firstMember = syntheticGroup.getRepresentative();
+ SynthesizingContext context = firstMember.getContext();
+ SyntheticClassBuilder builder =
+ new SyntheticClassBuilder(syntheticType, context, factory);
+ // TODO(b/158159959): Support grouping multiple methods per synthetic class.
+ builder.addMethod(
+ methodBuilder -> {
+ DexEncodedMethod definition = firstMember.getMethod().getDefinition();
+ methodBuilder
+ .setAccessFlags(definition.accessFlags)
+ .setProto(definition.getProto())
+ .setCode(m -> definition.getCode());
+ });
+ DexProgramClass externalSyntheticClass = builder.build();
+ assert externalSyntheticClass.getMethodCollection().size() == 1;
+ DexEncodedMethod externalSyntheticMethod =
+ externalSyntheticClass.methods().iterator().next();
+ newSyntheticClasses.add(externalSyntheticClass);
+ for (SyntheticMethodDefinition member : syntheticGroup.getMembers()) {
+ lensBuilder.map(
+ member.getMethod().getHolder().getType(), externalSyntheticClass.getType());
+ lensBuilder.map(member.getMethod().getReference(), externalSyntheticMethod.method);
+ DexType memberContext = member.getContextType();
+ DexProgramClass from =
+ DexProgramClass.asProgramClassOrNull(app.definitionFor(memberContext));
+ if (from != null) {
+ externalSyntheticClass.addSynthesizedFrom(from);
+ if (mainDexClasses.contains(from)) {
+ mainDexClasses.add(externalSyntheticClass);
+ }
+ }
+ }
+ });
+ }
+
+ private static <T extends SyntheticDefinition & Comparable<T>>
+ Map<DexType, EquivalenceGroup<T>> computeActualEquivalences(
+ Map<HashCode, List<T>> potentialEquivalences, DexItemFactory factory) {
+ Map<DexType, List<EquivalenceGroup<T>>> groupsPerContext = new IdentityHashMap<>();
+ potentialEquivalences.forEach(
+ (hash, members) -> {
+ // Get a representative member and add to its group.
+ T representative = findDeterministicRepresentative(members);
+ List<T> group = new ArrayList<>(members.size());
+ group.add(representative);
+ // Each other member is in the shared group if it is actually equal to the first member.
+ for (T member : members) {
+ if (member != representative) {
+ if (member.isEquivalentTo(representative)) {
+ group.add(member);
+ } else {
+ // The member becomes a new singleton group.
+ // TODO(b/158159959): Consider checking for sub-groups of matching members.
+ groupsPerContext
+ .computeIfAbsent(member.getContextType(), k -> new ArrayList<>())
+ .add(new EquivalenceGroup<>(member));
+ }
+ }
+ }
+ groupsPerContext
+ .computeIfAbsent(representative.getContextType(), k -> new ArrayList<>())
+ .add(new EquivalenceGroup<>(representative, group));
+ });
+ Map<DexType, EquivalenceGroup<T>> equivalences = new IdentityHashMap<>();
+ groupsPerContext.forEach(
+ (context, groups) -> {
+ groups.sort(EquivalenceGroup::compareTo);
+ for (int i = 0; i < groups.size(); i++) {
+ equivalences.put(createExternalType(context, i, factory), groups.get(i));
+ }
+ });
+ return equivalences;
+ }
+
+ private static <T extends SyntheticDefinition & Comparable<T>> T findDeterministicRepresentative(
+ List<T> members) {
+ // 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) {
+ 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 static <T extends SyntheticDefinition>
+ Map<HashCode, List<T>> computePotentialEquivalences(List<T> definitions) {
+ Map<HashCode, List<T>> equivalences = new HashMap<>(definitions.size());
+ for (T definition : definitions) {
+ HashCode hash = definition.computeHash();
+ equivalences.computeIfAbsent(hash, k -> new ArrayList<>()).add(definition);
+ }
+ return equivalences;
+ }
+
+ private List<SyntheticMethodDefinition> lookupSyntheticMethodDefinitions(
+ DexApplication finalApp) {
+ List<SyntheticMethodDefinition> methods = new ArrayList<>(syntheticItems.size());
+ for (SyntheticReference reference : syntheticItems.values()) {
+ SyntheticDefinition definition = reference.lookupDefinition(finalApp::definitionFor);
+ assert definition != null;
+ assert definition instanceof SyntheticMethodDefinition;
+ if (definition != null && definition instanceof SyntheticMethodDefinition) {
+ methods.add(((SyntheticMethodDefinition) definition));
+ }
+ }
+ return methods;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
new file mode 100644
index 0000000..b3c179f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -0,0 +1,360 @@
+// 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.errors.InternalCompilerError;
+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.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.synthesis.SyntheticFinalization.Result;
+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;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+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. */
+ 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.
+ * TODO(b/158159959): Remove legacy support.
+ */
+ private final Map<DexType, DexProgramClass> legacyPendingClasses = new ConcurrentHashMap<>();
+
+ /**
+ * Immutable set of synthetic types in the application (eg, committed). 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> pendingDefinitions =
+ new ConcurrentHashMap<>();
+
+ /** Mapping from synthetic type to its synthetic description. */
+ private final ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems;
+
+ // Only for use from initial AppInfo/AppInfoWithClassHierarchy create functions. */
+ public static SyntheticItems createInitialSyntheticItems() {
+ return new SyntheticItems(0, ImmutableSet.of(), ImmutableMap.of());
+ }
+
+ // Only for conversion to a mutable synthetic items collection.
+ SyntheticItems(CommittedItems commit) {
+ this(commit.nextSyntheticId, commit.legacySyntheticTypes, commit.syntheticItems);
+ }
+
+ private SyntheticItems(
+ int nextSyntheticId,
+ ImmutableSet<DexType> legacySyntheticTypes,
+ ImmutableMap<DexType, SyntheticReference> nonLecacySyntheticItems) {
+ this.nextSyntheticId = nextSyntheticId;
+ this.legacySyntheticTypes = legacySyntheticTypes;
+ this.nonLecacySyntheticItems = nonLecacySyntheticItems;
+ assert nonLecacySyntheticItems.keySet().stream()
+ .noneMatch(
+ t -> t.toDescriptorString().endsWith(getSyntheticDescriptorSuffix(nextSyntheticId)));
+ assert Sets.intersection(nonLecacySyntheticItems.keySet(), legacySyntheticTypes).isEmpty();
+ }
+
+ // Internal synthetic id creation helpers.
+
+ private synchronized int getNextSyntheticId() {
+ if (nextSyntheticId == INVALID_ID_AFTER_SYNTHETIC_FINALIZATION) {
+ throw new InternalCompilerError(
+ "Unexpected attempt to synthesize classes after synthetic finalization.");
+ }
+ return nextSyntheticId++;
+ }
+
+ private static DexType hygienicType(
+ DexItemFactory factory, int syntheticId, SynthesizingContext context) {
+ String contextDesc = context.type.toDescriptorString();
+ String prefix = contextDesc.substring(0, contextDesc.length() - 1);
+ String syntheticDesc = prefix + getSyntheticDescriptorSuffix(syntheticId);
+ return factory.createType(syntheticDesc);
+ }
+
+ private static String getSyntheticDescriptorSuffix(int syntheticId) {
+ return INTERNAL_SYNTHETIC_CLASS_SEPARATOR + syntheticId + ";";
+ }
+
+ // Predicates and accessors.
+
+ @Override
+ public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
+ DexProgramClass pending = legacyPendingClasses.get(type);
+ if (pending == null) {
+ SyntheticDefinition item = pendingDefinitions.get(type);
+ if (item != null) {
+ pending = item.getHolder();
+ }
+ }
+ if (pending != null) {
+ assert baseDefinitionFor.apply(type) == null
+ : "Pending synthetic definition also present in the active program: " + type;
+ return pending;
+ }
+ return baseDefinitionFor.apply(type);
+ }
+
+ public boolean hasPendingSyntheticClasses() {
+ return !legacyPendingClasses.isEmpty() || !pendingDefinitions.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);
+ }
+
+ private boolean isCommittedSynthetic(DexType type) {
+ return nonLecacySyntheticItems.containsKey(type) || legacySyntheticTypes.contains(type);
+ }
+
+ public boolean isPendingSynthetic(DexType type) {
+ return pendingDefinitions.containsKey(type) || legacyPendingClasses.containsKey(type);
+ }
+
+ public boolean isSyntheticClass(DexType type) {
+ return isCommittedSynthetic(type)
+ || isPendingSynthetic(type)
+ // TODO(b/158159959): Remove usage of name-based identification.
+ || type.isD8R8SynthesizedClassType();
+ }
+
+ public boolean isSyntheticClass(DexProgramClass clazz) {
+ return isSyntheticClass(clazz.type);
+ }
+
+ public Collection<DexProgramClass> getLegacyPendingClasses() {
+ return Collections.unmodifiableCollection(legacyPendingClasses.values());
+ }
+
+ private SynthesizingContext getSynthesizingContext(DexProgramClass context) {
+ SyntheticDefinition pendingItemContext = pendingDefinitions.get(context.type);
+ if (pendingItemContext != null) {
+ return pendingItemContext.getContext();
+ }
+ SyntheticReference committedItemContext = nonLecacySyntheticItems.get(context.type);
+ return committedItemContext != null
+ ? committedItemContext.getContext()
+ : new SynthesizingContext(context.type, context.origin);
+ }
+
+ // Addition and creation of synthetic items.
+
+ // TODO(b/158159959): Remove the usage of this direct class addition (and name-based id).
+ public void addLegacySyntheticClass(DexProgramClass clazz) {
+ assert clazz.type.isD8R8SynthesizedClassType();
+ assert !isCommittedSynthetic(clazz.type);
+ DexProgramClass previous = legacyPendingClasses.put(clazz.type, clazz);
+ assert previous == null || previous == clazz;
+ }
+
+ /** Create a single synthetic method item. */
+ public ProgramMethod createMethod(
+ DexProgramClass context, DexItemFactory factory, Consumer<SyntheticMethodBuilder> fn) {
+ // Obtain the outer synthesizing context in the case the context itself is synthetic.
+ // The is to ensure a flat input-type -> synthetic-item mapping.
+ SynthesizingContext outerContext = getSynthesizingContext(context);
+ DexType type = hygienicType(factory, getNextSyntheticId(), outerContext);
+ DexProgramClass clazz =
+ new SyntheticClassBuilder(type, outerContext, factory).addMethod(fn).build();
+ ProgramMethod method = new ProgramMethod(clazz, clazz.methods().iterator().next());
+ addPendingDefinition(new SyntheticMethodDefinition(outerContext, method));
+ return method;
+ }
+
+ private void addPendingDefinition(SyntheticDefinition definition) {
+ pendingDefinitions.put(definition.getHolder().getType(), definition);
+ }
+
+ // Commit of the synthetic items to a new fully populated application.
+
+ public CommittedItems commit(DexApplication application) {
+ return commitPrunedClasses(application, Collections.emptySet());
+ }
+
+ public CommittedItems commitPrunedClasses(
+ DexApplication application, Set<DexType> removedClasses) {
+ return commit(
+ application,
+ removedClasses,
+ legacyPendingClasses,
+ legacySyntheticTypes,
+ pendingDefinitions,
+ nonLecacySyntheticItems,
+ nextSyntheticId);
+ }
+
+ public CommittedItems commitRewrittenWithLens(DexApplication application, NestedGraphLens 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);
+ 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()));
+ return commit(
+ application,
+ Collections.emptySet(),
+ legacyPendingClasses,
+ rewrittenLegacyTypes,
+ pendingDefinitions,
+ rewrittenItems.build(),
+ 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,
+ 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 amendedApplication;
+ if (pendingDefinitions.isEmpty()) {
+ mergedItems = filteredCopy(syntheticItems, removedClasses);
+ additions = 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;
+ }
+ 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();
+ 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);
+ }
+ });
+ }
+ }
+
+ private static boolean verifyClassesAreInApp(
+ DexApplication app, Collection<DexProgramClass> classes) {
+ for (DexProgramClass clazz : classes) {
+ assert app.programDefinitionFor(clazz.type) != null : "Missing synthetic: " + clazz.type;
+ }
+ return true;
+ }
+
+ // Finalization of synthetic items.
+
+ public Result computeFinalSynthetics(AppView<?> appView) {
+ assert !hasPendingSyntheticClasses();
+ return new SyntheticFinalization(
+ appView.options(), legacySyntheticTypes, nonLecacySyntheticItems)
+ .computeFinalSynthetics(appView);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
new file mode 100644
index 0000000..90e593c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.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 com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.DexAnnotationSet;
+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.MethodAccessFlags;
+import com.android.tools.r8.graph.ParameterAnnotationsList;
+
+public class SyntheticMethodBuilder {
+
+ public interface SyntheticCodeGenerator {
+ Code generate(DexMethod method);
+ }
+
+ private final SyntheticClassBuilder parent;
+ private final String name;
+ private DexProto proto = null;
+ private SyntheticCodeGenerator codeGenerator = null;
+ private MethodAccessFlags accessFlags = null;
+
+ SyntheticMethodBuilder(SyntheticClassBuilder parent, String name) {
+ this.parent = parent;
+ this.name = name;
+ }
+
+ public SyntheticMethodBuilder setProto(DexProto proto) {
+ this.proto = proto;
+ return this;
+ }
+
+ public SyntheticMethodBuilder setCode(SyntheticCodeGenerator codeGenerator) {
+ this.codeGenerator = codeGenerator;
+ return this;
+ }
+
+ public SyntheticMethodBuilder setAccessFlags(MethodAccessFlags accessFlags) {
+ this.accessFlags = accessFlags;
+ return this;
+ }
+
+ DexEncodedMethod build() {
+ boolean isCompilerSynthesized = true;
+ DexMethod methodSignature = getMethodSignature();
+ return new DexEncodedMethod(
+ methodSignature,
+ getAccessFlags(),
+ getAnnotations(),
+ getParameterAnnotations(),
+ getCodeObject(methodSignature),
+ isCompilerSynthesized);
+ }
+
+ private DexMethod getMethodSignature() {
+ return parent.getFactory().createMethod(parent.getType(), proto, name);
+ }
+
+ private MethodAccessFlags getAccessFlags() {
+ return accessFlags;
+ }
+
+ private DexAnnotationSet getAnnotations() {
+ return DexAnnotationSet.empty();
+ }
+
+ private ParameterAnnotationsList getParameterAnnotations() {
+ return ParameterAnnotationsList.empty();
+ }
+
+ private Code getCodeObject(DexMethod methodSignature) {
+ return codeGenerator.generate(methodSignature);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
new file mode 100644
index 0000000..6fb07c5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodDefinition.java
@@ -0,0 +1,67 @@
+// 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.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.google.common.hash.HashCode;
+import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
+import java.util.Comparator;
+
+/**
+ * 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> {
+
+ private final ProgramMethod method;
+
+ SyntheticMethodDefinition(SynthesizingContext context, ProgramMethod method) {
+ super(context);
+ this.method = method;
+ }
+
+ public ProgramMethod getMethod() {
+ return method;
+ }
+
+ @Override
+ SyntheticReference toReference() {
+ return new SyntheticMethodReference(getContext(), method.getReference());
+ }
+
+ @Override
+ DexProgramClass getHolder() {
+ return method.getHolder();
+ }
+
+ @Override
+ HashCode computeHash() {
+ Hasher hasher = Hashing.sha256().newHasher();
+ method.getDefinition().hashSyntheticContent(hasher);
+ return hasher.hash();
+ }
+
+ @Override
+ boolean isEquivalentTo(SyntheticDefinition other) {
+ if (!(other instanceof SyntheticMethodDefinition)) {
+ return false;
+ }
+ SyntheticMethodDefinition o = (SyntheticMethodDefinition) other;
+ return method.getDefinition().isSyntheticContentEqual(o.method.getDefinition());
+ }
+
+ // 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::getContextType, DexType::slowCompareTo)
+ .thenComparing(m -> m.method.getDefinition(), DexEncodedMethod::syntheticCompareTo)
+ .compare(this, other);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
new file mode 100644
index 0000000..326eee0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
@@ -0,0 +1,50 @@
+// 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.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.graph.ProgramMethod;
+import java.util.function.Function;
+
+/**
+ * Reference to a synthetic method item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+class SyntheticMethodReference extends SyntheticReference {
+ final DexMethod method;
+
+ SyntheticMethodReference(SynthesizingContext context, DexMethod method) {
+ super(context);
+ this.method = method;
+ }
+
+ @Override
+ DexType getHolder() {
+ return method.holder;
+ }
+
+ @Override
+ SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
+ DexClass clazz = definitions.apply(method.holder);
+ if (clazz == null) {
+ return null;
+ }
+ assert clazz.isProgramClass();
+ ProgramMethod definition = clazz.asProgramClass().lookupProgramMethod(this.method);
+ return new SyntheticMethodDefinition(getContext(), definition);
+ }
+
+ @Override
+ SyntheticReference rewrite(NestedGraphLens lens) {
+ SynthesizingContext context = getContext().rewrite(lens);
+ DexMethod rewritten = lens.lookupMethod(method);
+ return context == getContext() && rewritten == method
+ ? this
+ : new SyntheticMethodReference(context, method);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
new file mode 100644
index 0000000..9981624
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
@@ -0,0 +1,41 @@
+// 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.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.origin.Origin;
+import java.util.function.Function;
+
+/**
+ * Base type for a reference to a synthetic item.
+ *
+ * <p>This class is internal to the synthetic items collection, thus package-protected.
+ */
+abstract class SyntheticReference {
+ private final SynthesizingContext context;
+
+ SyntheticReference(SynthesizingContext context) {
+ this.context = context;
+ }
+
+ abstract SyntheticDefinition lookupDefinition(Function<DexType, DexClass> definitions);
+
+ final SynthesizingContext getContext() {
+ return context;
+ }
+
+ final DexType getContextType() {
+ return context.type;
+ }
+
+ final Origin getContextOrigin() {
+ return context.origin;
+ }
+
+ abstract DexType getHolder();
+
+ abstract SyntheticReference rewrite(NestedGraphLens lens);
+}
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index c23e47d..0164b4e 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -32,7 +32,10 @@
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.InternalCompilerError;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.features.FeatureSplitConfiguration;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.origin.ArchiveEntryOrigin;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
@@ -472,7 +475,7 @@
dumpFeatureSplitFileNames(options.featureSplitConfiguration),
nextDexIndex,
out,
- options.featureSplitConfiguration);
+ options);
nextDexIndex = dumpClasspathResources(nextDexIndex, out);
nextDexIndex = dumpLibraryResources(nextDexIndex, out);
} catch (IOException | ResourceException e) {
@@ -534,12 +537,16 @@
Map<FeatureSplit, String> featureSplitArchiveNames,
int nextDexIndex,
ZipOutputStream out,
- FeatureSplitConfiguration featureSplitConfiguration)
+ InternalOptions options)
throws IOException, ResourceException {
Map<FeatureSplit, ByteArrayOutputStream> featureSplitArchiveByteStreams =
new IdentityHashMap<>();
Map<FeatureSplit, ZipOutputStream> featureSplitArchiveOutputStreams = new IdentityHashMap<>();
try {
+ DexItemFactory dexItemFactory = options.dexItemFactory();
+ FeatureSplitConfiguration featureSplitConfiguration = options.featureSplitConfiguration;
+ ClassToFeatureSplitMap classToFeatureSplitMap =
+ ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(options);
if (featureSplitConfiguration != null) {
for (FeatureSplit featureSplit : featureSplitConfiguration.getFeatureSplits()) {
ByteArrayOutputStream archiveByteStream = new ByteArrayOutputStream();
@@ -567,9 +574,8 @@
nextDexIndex,
classDescriptor -> {
if (featureSplitConfiguration != null) {
- FeatureSplit featureSplit =
- featureSplitConfiguration.getFeatureSplitFromClassDescriptor(
- classDescriptor);
+ DexType type = dexItemFactory.createType(classDescriptor);
+ FeatureSplit featureSplit = classToFeatureSplitMap.getFeatureSplit(type);
if (featureSplit != null) {
return featureSplitArchiveOutputStreams.get(featureSplit);
}
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 a9d5c3d..cf31dec 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -104,6 +104,10 @@
public final DexItemFactory itemFactory;
+ public DexItemFactory dexItemFactory() {
+ return itemFactory;
+ }
+
public boolean hasProguardConfiguration() {
return proguardConfiguration != null;
}
@@ -370,7 +374,7 @@
}
public boolean shouldBackportMethods() {
- return !hasConsumer() || isGeneratingDex();
+ return !hasConsumer() || isGeneratingDex() || cfToCfDesugar;
}
public boolean shouldKeepStackMapTable() {
diff --git a/src/test/java/com/android/tools/r8/DesugarTestBuilder.java b/src/test/java/com/android/tools/r8/DesugarTestBuilder.java
new file mode 100644
index 0000000..33ef940
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/DesugarTestBuilder.java
@@ -0,0 +1,44 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import com.android.tools.r8.utils.Pair;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+public class DesugarTestBuilder
+ extends TestBuilderCollection<
+ DesugarTestConfiguration, DesugarTestRunResult, DesugarTestBuilder> {
+
+ public static DesugarTestBuilder create(
+ TestState state,
+ List<Pair<DesugarTestConfiguration, TestBuilder<? extends TestRunResult<?>, ?>>>
+ testBuilders) {
+ return new DesugarTestBuilder(state, testBuilders);
+ }
+
+ private DesugarTestBuilder(
+ TestState state,
+ List<Pair<DesugarTestConfiguration, TestBuilder<? extends TestRunResult<?>, ?>>> builders) {
+ super(state, builders);
+ }
+
+ @Override
+ DesugarTestBuilder self() {
+ return this;
+ }
+
+ @Override
+ public DesugarTestRunResult run(TestRuntime runtime, String mainClass, String... args)
+ throws CompilationFailedException, ExecutionException, IOException {
+ List<Pair<DesugarTestConfiguration, TestRunResult<?>>> runs = new ArrayList<>(builders.size());
+ for (Pair<DesugarTestConfiguration, TestBuilder<? extends TestRunResult<?>, ?>> builder :
+ builders) {
+ runs.add(new Pair<>(builder.getFirst(), builder.getSecond().run(runtime, mainClass, args)));
+ }
+ return DesugarTestRunResult.create(runs);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/DesugarTestConfiguration.java b/src/test/java/com/android/tools/r8/DesugarTestConfiguration.java
new file mode 100644
index 0000000..c748ad3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/DesugarTestConfiguration.java
@@ -0,0 +1,32 @@
+// 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;
+
+/** The configurations for a desugar test */
+public enum DesugarTestConfiguration {
+ // Javac generated code with no desugaring (reference run).
+ JAVAC,
+ // Javac generated code with desugaring to class file.
+ D8_CF,
+ // Javac generated code with desugaring to DEX.
+ D8_DEX,
+ // Javac generated code with desugaring to class file and then compiled to DEX without desugaring.
+ D8_CF_D8_DEX;
+
+ public static boolean isJavac(DesugarTestConfiguration c) {
+ return c == JAVAC;
+ }
+
+ public static boolean isNotJavac(DesugarTestConfiguration c) {
+ return c != JAVAC;
+ }
+
+ public static boolean isNotDesugared(DesugarTestConfiguration c) {
+ return isJavac(c);
+ }
+
+ public static boolean isDesugared(DesugarTestConfiguration c) {
+ return isNotJavac(c);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/DesugarTestRunResult.java b/src/test/java/com/android/tools/r8/DesugarTestRunResult.java
new file mode 100644
index 0000000..4bffdfa
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/DesugarTestRunResult.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import com.android.tools.r8.utils.Pair;
+import java.util.List;
+
+public class DesugarTestRunResult
+ extends TestRunResultCollection<DesugarTestConfiguration, DesugarTestRunResult> {
+
+ public static DesugarTestRunResult create(
+ List<Pair<DesugarTestConfiguration, TestRunResult<?>>> runs) {
+ assert !runs.isEmpty();
+ return new DesugarTestRunResult(runs);
+ }
+
+ private DesugarTestRunResult(List<Pair<DesugarTestConfiguration, TestRunResult<?>>> runs) {
+ super(runs);
+ }
+
+ @Override
+ DesugarTestRunResult self() {
+ return this;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/NeverMerge.java b/src/test/java/com/android/tools/r8/NoHorizontalClassMerging.java
similarity index 71%
copy from src/test/java/com/android/tools/r8/NeverMerge.java
copy to src/test/java/com/android/tools/r8/NoHorizontalClassMerging.java
index 7c6922a..8e45d4a 100644
--- a/src/test/java/com/android/tools/r8/NeverMerge.java
+++ b/src/test/java/com/android/tools/r8/NoHorizontalClassMerging.java
@@ -1,10 +1,11 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
+
package com.android.tools.r8;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.TYPE})
-public @interface NeverMerge {}
+public @interface NoHorizontalClassMerging {}
diff --git a/src/test/java/com/android/tools/r8/NeverMerge.java b/src/test/java/com/android/tools/r8/NoStaticClassMerging.java
similarity index 72%
copy from src/test/java/com/android/tools/r8/NeverMerge.java
copy to src/test/java/com/android/tools/r8/NoStaticClassMerging.java
index 7c6922a..b97416f 100644
--- a/src/test/java/com/android/tools/r8/NeverMerge.java
+++ b/src/test/java/com/android/tools/r8/NoStaticClassMerging.java
@@ -1,10 +1,11 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
+
package com.android.tools.r8;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.TYPE})
-public @interface NeverMerge {}
+public @interface NoStaticClassMerging {}
diff --git a/src/test/java/com/android/tools/r8/NeverMerge.java b/src/test/java/com/android/tools/r8/NoVerticalClassMerging.java
similarity index 88%
rename from src/test/java/com/android/tools/r8/NeverMerge.java
rename to src/test/java/com/android/tools/r8/NoVerticalClassMerging.java
index 7c6922a..33d15ce 100644
--- a/src/test/java/com/android/tools/r8/NeverMerge.java
+++ b/src/test/java/com/android/tools/r8/NoVerticalClassMerging.java
@@ -7,4 +7,4 @@
import java.lang.annotation.Target;
@Target({ElementType.TYPE})
-public @interface NeverMerge {}
+public @interface NoVerticalClassMerging {}
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 3c8a16b..85705d2 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -4,6 +4,7 @@
package com.android.tools.r8;
import static com.android.tools.r8.dexsplitter.SplitterTestBase.simpleSplitProvider;
+import static com.android.tools.r8.dexsplitter.SplitterTestBase.splitWithNonJavaFile;
import static org.hamcrest.CoreMatchers.containsString;
import com.android.tools.r8.R8Command.Builder;
@@ -15,12 +16,16 @@
import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.CollectingGraphConsumer;
+import com.android.tools.r8.shaking.NoHorizontalClassMergingRule;
+import com.android.tools.r8.shaking.NoStaticClassMergingRule;
+import com.android.tools.r8.shaking.NoVerticalClassMergingRule;
import com.android.tools.r8.shaking.ProguardConfiguration;
import com.android.tools.r8.shaking.ProguardConfigurationRule;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.Pair;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
@@ -55,7 +60,9 @@
private boolean enableConstantArgumentAnnotations = false;
private boolean enableInliningAnnotations = false;
private boolean enableMemberValuePropagationAnnotations = false;
- private boolean enableMergeAnnotations = false;
+ private boolean enableNoVerticalClassMergingAnnotations = false;
+ private boolean enableNoHorizontalClassMergingAnnotations = false;
+ private boolean enableNoStaticClassMergingAnnotations = false;
private boolean enableNeverClassInliningAnnotations = false;
private boolean enableNeverReprocessClassInitializerAnnotations = false;
private boolean enableNeverReprocessMethodAnnotations = false;
@@ -76,7 +83,9 @@
if (enableConstantArgumentAnnotations
|| enableInliningAnnotations
|| enableMemberValuePropagationAnnotations
- || enableMergeAnnotations
+ || enableNoVerticalClassMergingAnnotations
+ || enableNoHorizontalClassMergingAnnotations
+ || enableNoStaticClassMergingAnnotations
|| enableNeverClassInliningAnnotations
|| enableNeverReprocessClassInitializerAnnotations
|| enableNeverReprocessMethodAnnotations
@@ -406,10 +415,38 @@
return self();
}
- public T enableMergeAnnotations() {
- if (!enableMergeAnnotations) {
- enableMergeAnnotations = true;
- addInternalKeepRules("-nevermerge @com.android.tools.r8.NeverMerge class *");
+ private void addInternalMatchInterfaceRule(String name, Class matchInterface) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("-");
+ sb.append(name);
+ sb.append(" @");
+ sb.append(matchInterface.getTypeName());
+ sb.append(" class *");
+ addInternalKeepRules(sb.toString());
+ }
+
+ public T enableNoVerticalClassMergingAnnotations() {
+ if (!enableNoVerticalClassMergingAnnotations) {
+ enableNoVerticalClassMergingAnnotations = true;
+ addInternalMatchInterfaceRule(
+ NoVerticalClassMergingRule.RULE_NAME, NoVerticalClassMerging.class);
+ }
+ return self();
+ }
+
+ public T enableNoHorizontalClassMergingAnnotations() {
+ if (!enableNoHorizontalClassMergingAnnotations) {
+ enableNoHorizontalClassMergingAnnotations = true;
+ addInternalMatchInterfaceRule(
+ NoHorizontalClassMergingRule.RULE_NAME, NoHorizontalClassMerging.class);
+ }
+ return self();
+ }
+
+ public T enableNoStaticClassMergingAnnotations() {
+ if (!enableNoStaticClassMergingAnnotations) {
+ enableNoStaticClassMergingAnnotations = true;
+ addInternalMatchInterfaceRule(NoStaticClassMergingRule.RULE_NAME, NoStaticClassMerging.class);
}
return self();
}
@@ -593,4 +630,14 @@
features.add(path);
return self();
}
+
+ public T addFeatureSplitWithResources(
+ Collection<Pair<String, String>> nonJavaFiles, Class<?>... classes) throws IOException {
+ Path path = getState().getNewTempFolder().resolve("feature.zip");
+ builder.addFeatureSplit(
+ builder ->
+ splitWithNonJavaFile(builder, path, getState().getTempFolder(), nonJavaFiles, classes));
+ features.add(path);
+ return self();
+ }
}
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 3fa1091..c2a1dac 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -71,6 +71,10 @@
return features.get(index);
}
+ public List<Path> getFeatures() {
+ return features;
+ }
+
@Override
public String getStdout() {
return state.getStdout();
@@ -132,6 +136,10 @@
return new R8TestRunResult(app, runtime, result, proguardMap, this::graphInspector);
}
+ public R8TestCompileResult addFeatureSplitsToRunClasspathFiles() {
+ return addRunClasspathFiles(features);
+ }
+
public R8TestRunResult runFeature(TestRuntime runtime, Class<?> mainFeatureClass)
throws IOException {
return runFeature(runtime, mainFeatureClass, features.get(0));
diff --git a/src/test/java/com/android/tools/r8/R8UnreachableCodeTest.java b/src/test/java/com/android/tools/r8/R8UnreachableCodeTest.java
deleted file mode 100644
index a022ecf..0000000
--- a/src/test/java/com/android/tools/r8/R8UnreachableCodeTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2016, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8;
-
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.dex.ApplicationReader;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DirectMappedDexApplication;
-import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.Timing;
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class R8UnreachableCodeTest {
-
- private static final Path SMALI_DIR = Paths.get(ToolHelper.SMALI_BUILD_DIR);
-
- @Ignore
- @Test
- public void UnreachableCode() throws IOException, ExecutionException {
- String name = "unreachable-code-1";
- AndroidApp input =
- AndroidApp.builder()
- .addProgramFiles(SMALI_DIR.resolve(name).resolve(name + ".dex"))
- .build();
- ExecutorService executorService = Executors.newSingleThreadExecutor();
- Timing timing = Timing.empty();
- InternalOptions options = new InternalOptions();
- options.programConsumer = DexIndexedConsumer.emptyConsumer();
- DirectMappedDexApplication application =
- new ApplicationReader(input, options, timing).read(executorService).toDirect();
- IRConverter converter = new IRConverter(AppView.createForR8(application), null);
- converter.optimize();
- DexProgramClass clazz = application.classes().iterator().next();
- assertEquals(4, clazz.getMethodCollection().numberOfDirectMethods());
- for (DexEncodedMethod method : clazz.directMethods()) {
- if (!method.method.name.toString().equals("main")) {
- assertEquals(2, method.getCode().asDexCode().instructions.length);
- }
- }
- }
-}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 342920c..d065497 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -20,6 +20,7 @@
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.dex.ApplicationReader;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppServices;
@@ -45,6 +46,8 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.EnqueuerFactory;
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;
@@ -76,6 +79,7 @@
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.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.collect.ImmutableList;
@@ -105,6 +109,7 @@
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.function.Predicate;
import java.util.jar.JarOutputStream;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -220,46 +225,78 @@
return testForRuntime(parameters.getRuntime(), parameters.getApiLevel());
}
- public TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(TestParameters parameters) {
+ public TestBuilder<DesugarTestRunResult, ?> testForDesugaring(TestParameters parameters) {
return testForDesugaring(
- parameters.getRuntime().getBackend(), parameters.getApiLevel(), o -> {});
+ parameters.getRuntime().getBackend(),
+ parameters.getApiLevel(),
+ o -> {},
+ Predicates.alwaysTrue());
}
- public TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(
+ public TestBuilder<DesugarTestRunResult, ?> testForDesugaring(
TestParameters parameters, Consumer<InternalOptions> optionsModification) {
return testForDesugaring(
- parameters.getRuntime().getBackend(), parameters.getApiLevel(), optionsModification);
+ parameters.getRuntime().getBackend(),
+ parameters.getApiLevel(),
+ optionsModification,
+ Predicates.alwaysTrue());
}
- private TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(
- Backend backend, AndroidApiLevel apiLevel, Consumer<InternalOptions> optionsModification) {
+ @Deprecated
+ // This is not supposed to be used for tests. It is here for debugging where filtering to run
+ // only some (typically one) test configuration is helpful.
+ public TestBuilder<DesugarTestRunResult, ?> testForDesugaring(
+ TestParameters parameters,
+ Consumer<InternalOptions> optionsModification,
+ Predicate<DesugarTestConfiguration> filter) {
+ return testForDesugaring(
+ parameters.getRuntime().getBackend(),
+ parameters.getApiLevel(),
+ optionsModification,
+ filter);
+ }
+
+ private TestBuilder<DesugarTestRunResult, ?> testForDesugaring(
+ Backend backend,
+ AndroidApiLevel apiLevel,
+ Consumer<InternalOptions> optionsModification,
+ Predicate<DesugarTestConfiguration> filter) {
assert apiLevel != null : "No API level. Add .withAllApiLevelsAlsoForCf() to test parameters?";
TestState state = new TestState(temp);
- List<Pair<String, TestBuilder<? extends TestRunResult<?>, ?>>> builders;
+ ImmutableList.Builder<
+ Pair<DesugarTestConfiguration, TestBuilder<? extends TestRunResult<?>, ?>>>
+ builders = ImmutableList.builder();
if (backend == Backend.CF) {
- builders =
- ImmutableList.of(
- new Pair<>("JAVAC", JvmTestBuilder.create(state)),
- new Pair<>(
- "D8/CF",
- D8TestBuilder.create(state, Backend.CF)
- .setMinApi(apiLevel)
- .addOptionsModification(optionsModification)));
+ if (filter.test(DesugarTestConfiguration.JAVAC)) {
+ builders.add(new Pair<>(DesugarTestConfiguration.JAVAC, JvmTestBuilder.create(state)));
+ }
+ if (filter.test(DesugarTestConfiguration.D8_CF)) {
+ builders.add(
+ new Pair<>(
+ DesugarTestConfiguration.D8_CF,
+ D8TestBuilder.create(state, Backend.CF)
+ .setMinApi(apiLevel)
+ .addOptionsModification(optionsModification)));
+ }
} else {
assert backend == Backend.DEX;
- builders =
- ImmutableList.of(
- new Pair<>(
- "D8/DEX",
- D8TestBuilder.create(state, Backend.DEX)
- .setMinApi(apiLevel)
- .addOptionsModification(optionsModification)),
- new Pair<>(
- "D8/DEX o D8/CF",
- IntermediateCfD8TestBuilder.create(state, apiLevel)
- .addOptionsModification(optionsModification)));
+ if (filter.test(DesugarTestConfiguration.D8_DEX)) {
+ builders.add(
+ new Pair<>(
+ DesugarTestConfiguration.D8_DEX,
+ D8TestBuilder.create(state, Backend.DEX)
+ .setMinApi(apiLevel)
+ .addOptionsModification(optionsModification)));
+ }
+ if (filter.test(DesugarTestConfiguration.D8_CF_D8_DEX)) {
+ builders.add(
+ new Pair<>(
+ DesugarTestConfiguration.D8_CF_D8_DEX,
+ IntermediateCfD8TestBuilder.create(state, apiLevel)
+ .addOptionsModification(optionsModification)));
+ }
}
- return TestBuilderCollection.create(state, builders);
+ return DesugarTestBuilder.create(state, builders.build());
}
public ProguardTestBuilder testForProguard() {
@@ -652,6 +689,7 @@
throws Exception {
return AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
readApplicationForDexOutput(app, new InternalOptions()),
+ ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap(),
MainDexClasses.createEmptyMainDexClasses());
}
@@ -1053,8 +1091,19 @@
+ keepMainProguardConfiguration(clazz);
}
- public static String neverMergeRule() {
- return "-nevermerge @com.android.tools.r8.NeverMerge class *";
+ @Deprecated
+ private static String matchInterfaceRule(String name, Class matchInterface) {
+ return "-" + name + " @" + matchInterface.getTypeName() + " class *";
+ }
+
+ @Deprecated
+ public static String noVerticalClassMergingRule() {
+ return matchInterfaceRule(NoVerticalClassMergingRule.RULE_NAME, NoVerticalClassMerging.class);
+ }
+
+ @Deprecated
+ public static String noStaticClassMergingRule() {
+ return matchInterfaceRule(NoStaticClassMergingRule.RULE_NAME, NoStaticClassMerging.class);
}
/**
diff --git a/src/test/java/com/android/tools/r8/TestBuilder.java b/src/test/java/com/android/tools/r8/TestBuilder.java
index 73a1605..8534d9f 100644
--- a/src/test/java/com/android/tools/r8/TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestBuilder.java
@@ -174,7 +174,9 @@
KeepUnusedArguments.class,
NeverClassInline.class,
NeverInline.class,
- NeverMerge.class,
+ NoVerticalClassMerging.class,
+ NoHorizontalClassMerging.class,
+ NoStaticClassMerging.class,
NeverPropagateValue.class);
}
diff --git a/src/test/java/com/android/tools/r8/TestBuilderCollection.java b/src/test/java/com/android/tools/r8/TestBuilderCollection.java
index a537aea..0192832 100644
--- a/src/test/java/com/android/tools/r8/TestBuilderCollection.java
+++ b/src/test/java/com/android/tools/r8/TestBuilderCollection.java
@@ -6,49 +6,28 @@
import com.android.tools.r8.debug.DebugTestConfig;
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.utils.Pair;
-import java.io.IOException;
import java.nio.file.Path;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
/** Abstraction to allow setup and execution of multiple test builders. */
-public class TestBuilderCollection
- extends TestBuilder<TestRunResultCollection, TestBuilderCollection> {
+public abstract class TestBuilderCollection<
+ C extends Enum<C>,
+ RR extends TestRunResultCollection<C, RR>,
+ T extends TestBuilderCollection<C, RR, T>>
+ extends TestBuilder<RR, T> {
- public static TestBuilderCollection create(
- TestState state,
- List<Pair<String, TestBuilder<? extends TestRunResult<?>, ?>>> testBuilders) {
- return new TestBuilderCollection(state, testBuilders);
- }
+ final List<Pair<C, TestBuilder<? extends TestRunResult<?>, ?>>> builders;
- private final List<Pair<String, TestBuilder<? extends TestRunResult<?>, ?>>> builders;
-
- private TestBuilderCollection(
- TestState state, List<Pair<String, TestBuilder<? extends TestRunResult<?>, ?>>> builders) {
+ TestBuilderCollection(
+ TestState state, List<Pair<C, TestBuilder<? extends TestRunResult<?>, ?>>> builders) {
super(state);
assert !builders.isEmpty();
this.builders = builders;
}
- @Override
- TestBuilderCollection self() {
- return this;
- }
-
- @Override
- public TestRunResultCollection run(TestRuntime runtime, String mainClass, String... args)
- throws CompilationFailedException, ExecutionException, IOException {
- List<Pair<String, TestRunResult<?>>> runs = new ArrayList<>(builders.size());
- for (Pair<String, TestBuilder<? extends TestRunResult<?>, ?>> builder : builders) {
- runs.add(new Pair<>(builder.getFirst(), builder.getSecond().run(runtime, mainClass, args)));
- }
- return TestRunResultCollection.create(runs);
- }
-
- private TestBuilderCollection forEach(Consumer<TestBuilder<? extends TestRunResult<?>, ?>> fn) {
+ private T forEach(Consumer<TestBuilder<? extends TestRunResult<?>, ?>> fn) {
builders.forEach(b -> fn.accept(b.getSecond()));
return self();
}
@@ -59,42 +38,42 @@
}
@Override
- public TestBuilderCollection addProgramFiles(Collection<Path> files) {
+ public T addProgramFiles(Collection<Path> files) {
return forEach(b -> b.addProgramFiles(files));
}
@Override
- public TestBuilderCollection addProgramClassFileData(Collection<byte[]> classes) {
+ public T addProgramClassFileData(Collection<byte[]> classes) {
return forEach(b -> b.addProgramClassFileData(classes));
}
@Override
- public TestBuilderCollection addProgramDexFileData(Collection<byte[]> data) {
+ public T addProgramDexFileData(Collection<byte[]> data) {
return forEach(b -> b.addProgramDexFileData(data));
}
@Override
- public TestBuilderCollection addLibraryFiles(Collection<Path> files) {
+ public T addLibraryFiles(Collection<Path> files) {
return forEach(b -> b.addLibraryFiles(files));
}
@Override
- public TestBuilderCollection addLibraryClasses(Collection<Class<?>> classes) {
+ public T addLibraryClasses(Collection<Class<?>> classes) {
return forEach(b -> b.addLibraryClasses(classes));
}
@Override
- public TestBuilderCollection addClasspathClasses(Collection<Class<?>> classes) {
+ public T addClasspathClasses(Collection<Class<?>> classes) {
return forEach(b -> b.addClasspathClasses(classes));
}
@Override
- public TestBuilderCollection addClasspathFiles(Collection<Path> files) {
+ public T addClasspathFiles(Collection<Path> files) {
return forEach(b -> b.addClasspathFiles(files));
}
@Override
- public TestBuilderCollection addRunClasspathFiles(Collection<Path> files) {
+ public T addRunClasspathFiles(Collection<Path> files) {
return forEach(b -> b.addRunClasspathFiles(files));
}
}
diff --git a/src/test/java/com/android/tools/r8/TestRunResultCollection.java b/src/test/java/com/android/tools/r8/TestRunResultCollection.java
index af4256a..4912ef8 100644
--- a/src/test/java/com/android/tools/r8/TestRunResultCollection.java
+++ b/src/test/java/com/android/tools/r8/TestRunResultCollection.java
@@ -6,70 +6,81 @@
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.ThrowingConsumer;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.base.Predicates;
import com.google.common.base.Strings;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
+import java.util.function.Predicate;
import org.hamcrest.Matcher;
/** Checking container for checking the same properties of multiple run results. */
-public class TestRunResultCollection extends TestRunResult<TestRunResultCollection> {
+public abstract class TestRunResultCollection<
+ C extends Enum<C>, RR extends TestRunResultCollection<C, RR>>
+ extends TestRunResult<RR> {
- public static TestRunResultCollection create(List<Pair<String, TestRunResult<?>>> runs) {
- assert !runs.isEmpty();
- return new TestRunResultCollection(runs);
- }
+ private final List<Pair<C, TestRunResult<?>>> runs;
- private final List<Pair<String, TestRunResult<?>>> runs;
-
- public TestRunResultCollection(List<Pair<String, TestRunResult<?>>> runs) {
+ public TestRunResultCollection(List<Pair<C, TestRunResult<?>>> runs) {
this.runs = runs;
}
- @Override
- TestRunResultCollection self() {
- return this;
- }
-
- private TestRunResultCollection forEach(Consumer<TestRunResult<?>> fn) {
+ private RR forEach(Consumer<TestRunResult<?>> fn) {
runs.forEach(r -> fn.accept(r.getSecond()));
return self();
}
@Override
- public TestRunResultCollection assertSuccess() {
+ public RR assertSuccess() {
return forEach(TestRunResult::assertSuccess);
}
@Override
- public TestRunResultCollection assertFailure() {
+ public RR assertFailure() {
return forEach(TestRunResult::assertFailure);
}
@Override
- public TestRunResultCollection assertStdoutMatches(Matcher<String> matcher) {
+ public RR assertStdoutMatches(Matcher<String> matcher) {
return forEach(r -> r.assertStdoutMatches(matcher));
}
@Override
- public TestRunResultCollection assertStderrMatches(Matcher<String> matcher) {
+ public RR assertStderrMatches(Matcher<String> matcher) {
return forEach(r -> r.assertStderrMatches(matcher));
}
@Override
- public <E extends Throwable> TestRunResultCollection inspect(
- ThrowingConsumer<CodeInspector, E> consumer) throws IOException, ExecutionException, E {
- for (Pair<String, TestRunResult<?>> run : runs) {
- run.getSecond().inspect(consumer);
+ public <E extends Throwable> RR inspect(ThrowingConsumer<CodeInspector, E> consumer)
+ throws IOException, ExecutionException, E {
+ return inspectIf(Predicates.alwaysTrue(), consumer);
+ }
+
+ public RR applyIf(Predicate<C> filter, Consumer<TestRunResult<?>> fn) {
+ for (Pair<C, TestRunResult<?>> run : runs) {
+ if (filter.test(run.getFirst())) {
+ fn.accept(run.getSecond());
+ }
+ }
+ return self();
+ }
+
+ public <E extends Throwable> RR inspectIf(
+ Predicate<C> filter, ThrowingConsumer<CodeInspector, E> consumer)
+ throws IOException, ExecutionException, E {
+ for (Pair<C, TestRunResult<?>> run : runs) {
+ if (filter.test(run.getFirst())) {
+ run.getSecond().inspect(consumer);
+ }
}
return self();
}
@Override
- public TestRunResultCollection disassemble() throws IOException, ExecutionException {
- for (Pair<String, TestRunResult<?>> run : runs) {
- String name = run.getFirst();
+ public RR disassemble() throws IOException, ExecutionException {
+ for (Pair<C, TestRunResult<?>> run : runs) {
+ String name = run.getFirst().name();
System.out.println(name + " " + Strings.repeat("=", 80 - name.length() - 1));
run.getSecond().disassemble();
}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 7de9a9a..e6fd9e0 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -121,6 +121,9 @@
public static final String JAVA_CLASSES_DIR = BUILD_DIR + "classes/java/";
public static final String JDK_11_TESTS_CLASSES_DIR = JAVA_CLASSES_DIR + "jdk11Tests/";
+ public static final String ASM_JAR = BUILD_DIR + "deps/asm-8.0.jar";
+ public static final String ASM_UTIL_JAR = BUILD_DIR + "deps/asm-util-8.0.jar";
+
public static final Path API_SAMPLE_JAR = Paths.get("tests", "r8_api_usage_sample.jar");
public static final String LINE_SEPARATOR = StringUtils.LINE_SEPARATOR;
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 2cb3e95..7521316 100644
--- a/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java
+++ b/src/test/java/com/android/tools/r8/accessrelaxation/NoRelaxationForSerializableTest.java
@@ -8,8 +8,8 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
@@ -31,7 +31,7 @@
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
-@NeverMerge
+@NoVerticalClassMerging
class MySerializable implements Serializable {
@NeverPropagateValue transient int value;
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/DataAdapter.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/DataAdapter.java
index 5209511..a4d94bb 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/DataAdapter.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/DataAdapter.java
@@ -4,11 +4,11 @@
package com.android.tools.r8.bridgeremoval.bridgestokeep;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public interface DataAdapter {
- @NeverMerge
+ @NoVerticalClassMerging
interface Observer extends ObservableList.Observer {}
void registerObserver(Observer observer);
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 3b7481b..0e373e9 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -54,7 +54,7 @@
.enableNeverClassInliningAnnotations()
// TODO(b/120764902): MemberSubject.getOriginalName() is not working without the @NeverMerge
// annotation on DataAdapter.Observer.
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableProguardTestOptions()
.minification(minification)
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
index 410d418..c9f7d21 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/BridgeHoistingAccessibilityTest.java
@@ -8,7 +8,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -72,7 +72,7 @@
.transform())
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -113,7 +113,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends BridgeHoistingAccessibilityTestClasses.A {
// This bridge cannot be hoisted to A, since it would then become inaccessible to the call site
@@ -136,7 +136,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class BWithRangedInvoke extends AWithRangedInvoke {
// This bridge cannot be hoisted to A, since it would then become inaccessible to the call site
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/InterfaceBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/InterfaceBridgeHoistingTest.java
index 9fdc87f..0e79433 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/InterfaceBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/InterfaceBridgeHoistingTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.transform())
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -53,10 +53,10 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
index b4ce765..fc6ac6b 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/KeptBridgeHoistingTest.java
@@ -8,7 +8,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,7 +43,7 @@
.addKeepMainRule(TestClass.class)
.addKeepRules("-keep class " + B.class.getTypeName() + " { java.lang.String bridge(...); }")
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -69,7 +69,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
index d93514a..02c948c 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonReboundBridgeHoistingTest.java
@@ -43,7 +43,7 @@
transformer(C.class).setBridge(C.class.getDeclaredMethod("bridge")).transform())
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
index 87310d2..f2a91a8 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/NonSuperclassBridgeHoistingTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,7 +43,7 @@
.transform())
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -70,7 +70,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/BridgeHoistingAccessibilityTestClasses.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/BridgeHoistingAccessibilityTestClasses.java
index 55daf92..9990f62 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/BridgeHoistingAccessibilityTestClasses.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/BridgeHoistingAccessibilityTestClasses.java
@@ -5,13 +5,13 @@
package com.android.tools.r8.bridgeremoval.hoisting.testclasses;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.bridgeremoval.hoisting.BridgeHoistingAccessibilityTest;
import com.android.tools.r8.bridgeremoval.hoisting.BridgeHoistingAccessibilityTest.CWithRangedInvoke;
public class BridgeHoistingAccessibilityTestClasses {
- @NeverMerge
+ @NoVerticalClassMerging
public static class A {
@NeverInline
@@ -28,7 +28,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class AWithRangedInvoke {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/NonReboundBridgeHoistingTestClasses.java b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/NonReboundBridgeHoistingTestClasses.java
index f66c6a3..c419f7f 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/NonReboundBridgeHoistingTestClasses.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/hoisting/testclasses/NonReboundBridgeHoistingTestClasses.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.bridgeremoval.hoisting.testclasses;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public class NonReboundBridgeHoistingTestClasses {
@@ -13,7 +13,7 @@
return A.class;
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
@@ -22,6 +22,6 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {}
}
diff --git a/src/test/java/com/android/tools/r8/cf/MethodHandleTest.java b/src/test/java/com/android/tools/r8/cf/MethodHandleTest.java
index c0067d6..690dd6b 100644
--- a/src/test/java/com/android/tools/r8/cf/MethodHandleTest.java
+++ b/src/test/java/com/android/tools/r8/cf/MethodHandleTest.java
@@ -4,7 +4,7 @@
package com.android.tools.r8.cf;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
@@ -82,7 +82,7 @@
// Class that is only mentioned in return value of LDC(MethodType)-instruction.
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
int ii = 42;
diff --git a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
index 3062ae8..2a6652b 100644
--- a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
@@ -177,7 +177,7 @@
builder.addProguardConfiguration(
Arrays.asList(
keepMainProguardConfiguration(MethodHandleTest.class),
- neverMergeRule(),
+ noVerticalClassMergingRule(),
// Prevent the second argument of C.svic(), C.sjic(), I.sjic() and I.svic() from
// being removed although they are never used unused. This is needed since these
// methods are accessed reflectively.
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
index 3f5b778..e2defd2 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -48,7 +48,7 @@
"-checkdiscard class **.*$" + targetClass.getSimpleName() + " { void gone(); }")
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.minification(minification)
.setMinApi(parameters.getRuntime())
// Asserting that -checkdiscard is not giving any information out on an un-removed
@@ -70,7 +70,7 @@
test(TestMain2.class, Itf.class);
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {
@NeverInline
void gone() {
@@ -93,7 +93,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
void gone();
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
index edd84cb..5eb49b1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import org.junit.Test;
@@ -27,7 +27,7 @@
.addKeepMainRule(Main.class)
.addOptionsModification(
options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -41,7 +41,7 @@
});
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public interface I {
void bar();
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
index c6f58af..70e7c0d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import org.junit.Test;
@@ -28,7 +28,7 @@
.addOptionsModification(
options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
@@ -42,7 +42,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void bar();
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java
new file mode 100644
index 0000000..075448a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java
@@ -0,0 +1,76 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import org.junit.Test;
+
+public class InnerOuterClassesTest extends HorizontalClassMergingTestBase {
+ public InnerOuterClassesTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableNeverClassInliningAnnotations()
+ .addKeepAttributes("InnerClasses", "EnclosingMethod")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b", "c", "d")
+ .inspect(
+ codeInspector -> {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(A.B.class), isPresent());
+ assertThat(codeInspector.clazz(C.class), isPresent());
+ assertThat(codeInspector.clazz(A.D.class), isPresent());
+ });
+ }
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+
+ @NeverClassInline
+ public static class B {
+ public B() {
+ System.out.println("b");
+ }
+ }
+
+ @NeverClassInline
+ public static class D {
+ public D() {
+ System.out.println("d");
+ }
+ }
+ }
+
+ @NeverClassInline
+ public static class C {
+ public C() {
+ System.out.println("c");
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ A a = new A();
+ A.B b = new A.B();
+ C c = new C();
+ A.D d = new A.D();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
index 1f0daeb..fc4f076 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
@@ -10,7 +10,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfRuntime;
import com.android.tools.r8.naming.retrace.StackTrace;
@@ -47,7 +47,7 @@
.addKeepAttributeSourceFile()
.addOptionsModification(
options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -77,7 +77,7 @@
});
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Parent {
Parent() {
if (System.currentTimeMillis() >= 0) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAnnotationsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAnnotationsTest.java
new file mode 100644
index 0000000..b7fc7a1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAnnotationsTest.java
@@ -0,0 +1,91 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.junit.Test;
+
+public class NoAnnotationsTest extends HorizontalClassMergingTestBase {
+ public NoAnnotationsTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addKeepClassRules(TypeAnnotation.class, MethodAnnotation.class)
+ .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableNeverClassInliningAnnotations()
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b", "c", "foo")
+ .inspect(
+ codeInspector -> {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ assertThat(codeInspector.clazz(C.class), isPresent());
+ });
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @Target({ElementType.TYPE})
+ public @interface TypeAnnotation {}
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @Target({ElementType.METHOD})
+ public @interface MethodAnnotation {}
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+ }
+
+ @TypeAnnotation
+ @NeverClassInline
+ public static class B {
+ public B(String v) {
+ System.out.println(v);
+ }
+ }
+
+ @NeverClassInline
+ public static class C {
+ public C(String v) {
+ System.out.println(v);
+ }
+
+ @NeverInline
+ @MethodAnnotation
+ public void foo() {
+ System.out.println("foo");
+ }
+ }
+
+ static class Main {
+ public static void main(String[] args) {
+ A a = new A();
+ B b = new B("b");
+ C c = new C("c");
+ c.foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java
new file mode 100644
index 0000000..dc513c3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestParameters;
+import org.junit.Test;
+
+public class NoHorizontalClassMergingTest extends HorizontalClassMergingTestBase {
+ public NoHorizontalClassMergingTest(
+ TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b")
+ .inspect(
+ codeInspector -> {
+ if (enableHorizontalClassMerging) {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ } else {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ }
+ });
+ }
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+ }
+
+ @NeverClassInline
+ @NoHorizontalClassMerging
+ public static class B {
+ public B(String v) {
+ System.out.println(v);
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ A a = new A();
+ B b = new B("b");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java
new file mode 100644
index 0000000..a1b0951
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.classmerging.horizontal.testclasses.A;
+import com.android.tools.r8.classmerging.horizontal.testclasses.B;
+import org.junit.Test;
+
+public class PackagePrivateMemberAccessTest extends HorizontalClassMergingTestBase {
+ public PackagePrivateMemberAccessTest(
+ TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addProgramClasses(A.class)
+ .addProgramClasses(B.class)
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .allowAccessModification(false)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("foo", "B", "bar", "5", "foobar")
+ .inspect(
+ codeInspector -> {
+ if (enableHorizontalClassMerging) {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), not(isPresent()));
+ assertThat(codeInspector.clazz(C.class), isPresent());
+ // TODO(b/165517236): Explicitly check classes have been merged.
+ } else {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ assertThat(codeInspector.clazz(C.class), isPresent());
+ }
+ });
+ }
+
+ @NeverClassInline
+ public static class C {
+ public C(int v) {
+ System.out.println(v);
+ }
+
+ public void foobar() {
+ System.out.println("foobar");
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ A a = new A();
+ a.foo();
+ B b = a.get("B");
+ b.bar();
+ C c = new C(5);
+ c.foobar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java
new file mode 100644
index 0000000..cdaeee7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.classmerging.horizontal.testclasses.C;
+import com.android.tools.r8.classmerging.horizontal.testclasses.D;
+import org.junit.Test;
+
+public class PackagePrivateMembersAccessedTest extends HorizontalClassMergingTestBase {
+ public PackagePrivateMembersAccessedTest(
+ TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addProgramClasses(C.class)
+ .addProgramClasses(D.class)
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .allowAccessModification(false)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("foo", "hello", "5", "foobar")
+ .inspect(
+ codeInspector -> {
+ assertThat(codeInspector.clazz(C.class), isPresent());
+ assertThat(codeInspector.clazz(D.class), isPresent());
+ assertThat(codeInspector.clazz(E.class), isPresent());
+ });
+ }
+
+ @NeverClassInline
+ public static class E {
+ public E(int v) {
+ System.out.println(v);
+ }
+
+ public void foobar() {
+ System.out.println("foobar");
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ D d = new D("foo");
+ C c = d.getC("hello");
+ c.bar();
+ E e = new E(5);
+ e.foobar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java
new file mode 100644
index 0000000..444d573
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java
@@ -0,0 +1,65 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import org.junit.Test;
+
+public class PinnedClassMemberTest extends HorizontalClassMergingTestBase {
+ public PinnedClassMemberTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addKeepRules("-keepclassmembers class " + B.class.getTypeName() + " { void foo(); }")
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b", "foo", "true")
+ .inspect(
+ codeInspector -> {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ });
+ }
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+ }
+
+ @NeverClassInline
+ public static class B {
+ public B(String s) {
+ System.out.println(s);
+ }
+
+ public void foo() {
+ System.out.println("foo");
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) throws Exception {
+ A a = new A();
+ B b = new B("b");
+ b.foo();
+
+ System.out.println(b.getClass().getMethod("foo").getName().equals("foo"));
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java
new file mode 100644
index 0000000..a2b36f3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java
@@ -0,0 +1,61 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import org.junit.Test;
+
+public class PinnedClassTest extends HorizontalClassMergingTestBase {
+ public PinnedClassTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addKeepClassRules(B.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b", "true", "true")
+ .inspect(
+ codeInspector -> {
+ assertThat(codeInspector.clazz(A.class), isPresent());
+ assertThat(codeInspector.clazz(B.class), isPresent());
+ });
+ }
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+ }
+
+ @NeverClassInline
+ public static class B {
+ public B(String s) {
+ System.out.println(s);
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ A a = new A();
+ B b = new B("b");
+
+ System.out.println(b.getClass().getSimpleName().equals("PinnedClassTest$B"));
+ System.out.println(!a.getClass().getSimpleName().equals("PinnedClassTest$B"));
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java
new file mode 100644
index 0000000..620f948
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java
@@ -0,0 +1,111 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.graph.DexEncodedAnnotation;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.junit.Test;
+
+public class ReferencedInAnnotationTest extends HorizontalClassMergingTestBase {
+
+ public ReferencedInAnnotationTest(
+ TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(Annotation.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .addKeepRuntimeVisibleAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!")
+ .inspect(this::inspect);
+ }
+
+ private void inspect(CodeInspector inspector) {
+ // TestClass and A should still be present.
+ ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+ assertThat(testClassSubject, isPresent());
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+
+ // B should have been merged into A if horizontal class merging is enabled.
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ assertThat(bClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+
+ // The annotation on TestClass should now refer to A instead of B.
+ AnnotationSubject annotationSubject =
+ testClassSubject.annotation(Annotation.class.getTypeName());
+ assertThat(annotationSubject, isPresent());
+
+ DexEncodedAnnotation encodedAnnotation = annotationSubject.getAnnotation();
+ assertEquals(1, encodedAnnotation.getNumberOfElements());
+
+ DexValue annotationElementValue = encodedAnnotation.getElement(0).getValue();
+ assertTrue(annotationElementValue.isDexValueType());
+
+ DexType annotationElementValueType = annotationElementValue.asDexValueType().getValue();
+ assertEquals(
+ (enableHorizontalClassMerging ? aClassSubject : bClassSubject)
+ .getDexProgramClass()
+ .getType(),
+ annotationElementValueType);
+ }
+
+ @Annotation(B.class)
+ public static class TestClass {
+
+ public static void main(String[] args) {
+ new A();
+ new B("");
+ }
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @Target({ElementType.TYPE})
+ @interface Annotation {
+ Class<?> value();
+ }
+
+ @NeverClassInline
+ public static class A {
+
+ public A() {
+ System.out.print("Hello");
+ }
+ }
+
+ @NeverClassInline
+ public static class B {
+
+ public B(String s) {
+ System.out.println(" world!");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodSuperMerged.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodSuperMerged.java
index f323ec7..19c458f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodSuperMerged.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodSuperMerged.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import org.junit.Test;
@@ -28,7 +28,7 @@
options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("foo", "parent b", "parent b", "x", "parent b")
@@ -57,7 +57,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public static class ParentB {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/A.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/A.java
new file mode 100644
index 0000000..ea0e1c9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/A.java
@@ -0,0 +1,20 @@
+// 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.classmerging.horizontal.testclasses;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+
+@NeverClassInline
+public class A {
+ public void foo() {
+ System.out.println("foo");
+ }
+
+ @NeverInline
+ public B get(String s) {
+ return new B(s);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/B.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/B.java
new file mode 100644
index 0000000..6157508
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/B.java
@@ -0,0 +1,20 @@
+// 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.classmerging.horizontal.testclasses;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+
+@NeverClassInline
+public class B {
+ protected B(String a) {
+ System.out.println(a);
+ }
+
+ @NeverInline
+ public void bar() {
+ System.out.println("bar");
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/C.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/C.java
new file mode 100644
index 0000000..f2220c0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/C.java
@@ -0,0 +1,22 @@
+// 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.classmerging.horizontal.testclasses;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+
+@NeverClassInline
+public class C {
+ String field;
+
+ protected C(String field) {
+ this.field = field;
+ }
+
+ @NeverInline
+ public void bar() {
+ System.out.println(field);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/D.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/D.java
new file mode 100644
index 0000000..3348d96
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/testclasses/D.java
@@ -0,0 +1,20 @@
+// 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.classmerging.horizontal.testclasses;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+
+@NeverClassInline
+public class D {
+ public D(String v) {
+ System.out.println(v);
+ }
+
+ @NeverInline
+ public C getC(String v) {
+ return new C(v);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontalstatic/HorizontalClassMergerSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontalstatic/HorizontalClassMergerSynchronizedMethodTest.java
index 8ddfef4..5f4945e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontalstatic/HorizontalClassMergerSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontalstatic/HorizontalClassMergerSynchronizedMethodTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,7 +53,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(HorizontalClassMergerSynchronizedMethodTest.class)
.addKeepMainRule(Main.class)
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), Main.class)
@@ -83,7 +83,7 @@
}
}
- @NeverMerge
+ @NoStaticClassMerging
public static class LockThree {
static synchronized void acquire(I c) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithMultiPackageAccessesTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithMultiPackageAccessesTest.java
index a96f8d3..d830cdb 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithMultiPackageAccessesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/ForceInlineConstructorWithMultiPackageAccessesTest.java
@@ -37,7 +37,7 @@
.addInnerClasses(ForceInlineConstructorWithMultiPackageAccessesTest.class)
.addInnerClasses(ForceInlineConstructorWithMultiPackageAccessesTestClasses.class)
.addKeepMainRule(TestClass.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSuperCallInStaticTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSuperCallInStaticTest.java
index 9de435b..90ec4c3 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSuperCallInStaticTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSuperCallInStaticTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -57,7 +57,7 @@
.addKeepMainRule(Main.class)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED)
@@ -82,7 +82,7 @@
.transform();
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class Base {
public void collect() {
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSynchronizedMethodTest.java
index deff6a8..ff081a4 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSynchronizedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerSynchronizedMethodTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,7 +53,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(VerticalClassMergerSynchronizedMethodTest.class)
.addKeepMainRule(Main.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutput("Hello World!")
@@ -73,7 +73,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class LockTwo extends LockOne {
static synchronized void acquire(I c) {
@@ -83,7 +83,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class LockThree {
static synchronized void acquire(I c) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/testclasses/ForceInlineConstructorWithMultiPackageAccessesTestClasses.java b/src/test/java/com/android/tools/r8/classmerging/vertical/testclasses/ForceInlineConstructorWithMultiPackageAccessesTestClasses.java
index 2b3967a..077c5e3 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/testclasses/ForceInlineConstructorWithMultiPackageAccessesTestClasses.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/testclasses/ForceInlineConstructorWithMultiPackageAccessesTestClasses.java
@@ -4,11 +4,11 @@
package com.android.tools.r8.classmerging.vertical.testclasses;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public class ForceInlineConstructorWithMultiPackageAccessesTestClasses {
- @NeverMerge
+ @NoVerticalClassMerging
public static class A {
protected A() {}
diff --git a/src/test/java/com/android/tools/r8/desugar/DefaultInterfaceWithIdentifierNameString.java b/src/test/java/com/android/tools/r8/desugar/DefaultInterfaceWithIdentifierNameString.java
index 9eb054c..9c006cb 100644
--- a/src/test/java/com/android/tools/r8/desugar/DefaultInterfaceWithIdentifierNameString.java
+++ b/src/test/java/com/android/tools/r8/desugar/DefaultInterfaceWithIdentifierNameString.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -70,7 +70,7 @@
.addKeepMainRule(TestClass.class)
.setMinApi(parameters.getApiLevel())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.compile()
.inspect(this::inspect)
@@ -86,7 +86,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
@NeverInline
static I newInstance() throws Exception {
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
index 7192449..b2d5b54 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
@@ -5,22 +5,22 @@
package com.android.tools.r8.desugar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.DesugarTestConfiguration;
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.ToolHelper.DexVm.Version;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import java.nio.file.Path;
+import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -29,6 +29,14 @@
@RunWith(Parameterized.class)
public class DesugarLambdaWithAnonymousClass extends TestBase {
+ private List<String> EXPECTED_JAVAC_RESULT =
+ ImmutableList.of("Hello from inside lambda$test$0", "Hello from inside lambda$testStatic$1");
+
+ private List<String> EXPECTED_DESUGARED_RESULT =
+ ImmutableList.of(
+ "Hello from inside lambda$test$0$DesugarLambdaWithAnonymousClass$TestClass",
+ "Hello from inside lambda$testStatic$1");
+
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
@@ -73,111 +81,55 @@
assertEquals(2, counter.getCount());
}
- // TODO(158752316): There should be no use of this check.
- private void checkEnclosingMethodWrong(CodeInspector inspector) {
- Counter counter = new Counter();
- inspector.forAllClasses(
- clazz -> {
- if (clazz.getFinalName().endsWith("$TestClass$1")
- || clazz.getFinalName().endsWith("$TestClass$2")) {
- counter.increment();
- assertTrue(clazz.isAnonymousClass());
- DexMethod enclosingMethod = clazz.getFinalEnclosingMethod();
- ClassSubject testClassSubject =
- inspector.clazz(DesugarLambdaWithAnonymousClass.TestClass.class);
- assertEquals(
- testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
- if (enclosingMethod.name.toString().contains("Static")) {
- assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
- isPresent());
- } else {
- assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
- not(isPresent()));
- }
- }
- });
- assertEquals(2, counter.getCount());
- }
-
- private void checkArtResult(D8TestRunResult result) {
- // TODO(158752316): This should neither return null nor fail.
- if (parameters.getRuntime().asDex().getVm().getVersion().isOlderThanOrEqual(Version.V4_4_4)
- || parameters.getRuntime().asDex().getVm().getVersion().isNewerThan(Version.V6_0_1)) {
- result.assertSuccessWithOutputLines(
- "Hello from inside <null>", "Hello from inside lambda$testStatic$1");
- } else {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- }
- }
-
@BeforeClass
public static void checkExpectedJavacNames() throws Exception {
CodeInspector inspector =
new CodeInspector(
- ToolHelper.getClassFilesForInnerClasses(DesugarLambdaWithLocalClass.class));
- String outer = DesugarLambdaWithLocalClass.class.getTypeName();
+ ToolHelper.getClassFilesForInnerClasses(DesugarLambdaWithAnonymousClass.class));
+ String outer = DesugarLambdaWithAnonymousClass.class.getTypeName();
ClassSubject testClass = inspector.clazz(outer + "$TestClass");
assertThat(testClass, isPresent());
assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
- assertThat(inspector.clazz(outer + "$TestClass$1MyConsumerImpl"), isPresent());
- assertThat(inspector.clazz(outer + "$TestClass$2MyConsumerImpl"), isPresent());
+ assertThat(inspector.clazz(outer + "$TestClass$1"), isPresent());
+ assertThat(inspector.clazz(outer + "$TestClass$2"), isPresent());
}
@Test
- public void testDefault() throws Exception {
- if (parameters.getRuntime().isCf()) {
- // Run on the JVM.
- testForJvm()
+ public void testDesugar() throws Exception {
+ testForDesugaring(parameters)
+ .addInnerClasses(DesugarLambdaWithAnonymousClass.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .inspect(this::checkEnclosingMethod)
+ .applyIf(
+ DesugarTestConfiguration::isNotDesugared,
+ r -> r.assertSuccessWithOutputLines(EXPECTED_JAVAC_RESULT))
+ .applyIf(
+ DesugarTestConfiguration::isDesugared,
+ r -> r.assertSuccessWithOutputLines(EXPECTED_DESUGARED_RESULT));
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ try {
+ testForR8(parameters.getBackend())
+ // TODO(b/158752316, b/157700141): Disable inlining to keep the synthetic lambda methods.
+ .addOptionsModification(options -> options.enableInlining = false)
.addInnerClasses(DesugarLambdaWithAnonymousClass.class)
- .run(parameters.getRuntime(), TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepRules("-keep class * { *; }")
+ // Keeping the synthetic lambda methods is currently not supported - they are
+ // forcefully unpinned. The following rule has no effect. See b/b/157700141.
+ .addKeepRules("-keep class **.*$TestClass { synthetic *; }")
+ .addKeepAttributes("InnerClasses", "EnclosingMethod")
+ .compile()
.inspect(this::checkEnclosingMethod)
- .assertSuccessWithOutputLines(
- "Hello from inside lambda$test$0", "Hello from inside lambda$testStatic$1");
- } else {
- assert parameters.getRuntime().isDex();
- // Run on Art.
- checkArtResult(
- testForD8()
- .addInnerClasses(DesugarLambdaWithAnonymousClass.class)
- .setMinApi(parameters.getApiLevel())
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .run(parameters.getRuntime(), TestClass.class));
- }
- }
-
- @Test
- public void testCfToCf() throws Exception {
- // Use D8 to desugar with Java classfile output.
- Path jar =
- testForD8(Backend.CF)
- .addInnerClasses(DesugarLambdaWithAnonymousClass.class)
- .setMinApi(parameters.getApiLevel())
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .writeToZip();
-
- if (parameters.getRuntime().isCf()) {
- // Run on the JVM.
- testForJvm()
- .addProgramFiles(jar)
.run(parameters.getRuntime(), TestClass.class)
- // TODO(158752316): This should not fail.
- .assertFailureWithErrorThatThrows(InternalError.class);
- } else {
- assert parameters.getRuntime().isDex();
- // Compile to DEX without desugaring and run on Art.
- checkArtResult(
- testForD8()
- .addProgramFiles(jar)
- .setMinApi(parameters.getApiLevel())
- .disableDesugaring()
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .run(parameters.getRuntime(), TestClass.class));
+ .assertSuccessWithOutputLines(
+ parameters.isCfRuntime() ? EXPECTED_JAVAC_RESULT : EXPECTED_DESUGARED_RESULT);
+ assertFalse(parameters.isDexRuntime());
+ } catch (AssertionError e) {
+ assertTrue(parameters.isDexRuntime());
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
index 68fd89e..8c539d2 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
@@ -5,22 +5,21 @@
package com.android.tools.r8.desugar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.DesugarTestConfiguration;
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.ToolHelper.DexVm.Version;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import java.nio.file.Path;
+import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -29,6 +28,17 @@
@RunWith(Parameterized.class)
public class DesugarLambdaWithLocalClass extends TestBase {
+ private List<String> EXPECTED_JAVAC_RESULT =
+ ImmutableList.of("Hello from inside lambda$test$0", "Hello from inside lambda$testStatic$1");
+
+ private List<String> EXPECTED_DESUGARED_RESULT =
+ ImmutableList.of(
+ "Hello from inside lambda$test$0$DesugarLambdaWithLocalClass$TestClass",
+ "Hello from inside lambda$testStatic$1");
+
+ private List<String> EXPECTED_DESUGARED_RESULT_R8_WITHOUT_INLINING =
+ ImmutableList.of("Hello from inside lambda$test$0", "Hello from inside lambda$testStatic$1");
+
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
@@ -56,7 +66,8 @@
Counter counter = new Counter();
inspector.forAllClasses(
clazz -> {
- if (clazz.getFinalName().endsWith("MyConsumerImpl")) {
+ if (clazz.getFinalName().endsWith("$TestClass$1MyConsumerImpl")
+ || clazz.getFinalName().endsWith("$TestClass$2MyConsumerImpl")) {
counter.increment();
assertTrue(clazz.isLocalClass());
DexMethod enclosingMethod = clazz.getFinalEnclosingMethod();
@@ -71,111 +82,53 @@
assertEquals(2, counter.getCount());
}
- // TODO(158752316): There should be no use of this check.
- private void checkEnclosingMethodWrong(CodeInspector inspector) {
- Counter counter = new Counter();
- inspector.forAllClasses(
- clazz -> {
- if (clazz.getFinalName().endsWith("$TestClass$1MyConsumerImpl")
- || clazz.getFinalName().endsWith("$TestClass$2MyConsumerImpl")) {
- counter.increment();
- assertTrue(clazz.isLocalClass());
- DexMethod enclosingMethod = clazz.getFinalEnclosingMethod();
- ClassSubject testClassSubject = inspector.clazz(TestClass.class);
- assertEquals(
- testClassSubject, inspector.clazz(enclosingMethod.holder.toSourceString()));
- if (enclosingMethod.name.toString().contains("Static")) {
- assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
- isPresent());
- } else {
- assertThat(
- testClassSubject.uniqueMethodWithName(enclosingMethod.name.toString()),
- not(isPresent()));
- }
- }
- });
- assertEquals(2, counter.getCount());
- }
-
- private void checkArtResult(D8TestRunResult result) {
- // TODO(158752316): This should neither return null nor fail.
- if (parameters.getRuntime().asDex().getVm().getVersion().isOlderThanOrEqual(Version.V4_4_4)
- || parameters.getRuntime().asDex().getVm().getVersion().isNewerThan(Version.V6_0_1)) {
- result.assertSuccessWithOutputLines(
- "Hello from inside <null>", "Hello from inside lambda$testStatic$1");
- } else {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- }
- }
-
@BeforeClass
public static void checkExpectedJavacNames() throws Exception {
CodeInspector inspector =
new CodeInspector(
- ToolHelper.getClassFilesForInnerClasses(DesugarLambdaWithAnonymousClass.class));
- String outer = DesugarLambdaWithAnonymousClass.class.getTypeName();
+ ToolHelper.getClassFilesForInnerClasses(DesugarLambdaWithLocalClass.class));
+ String outer = DesugarLambdaWithLocalClass.class.getTypeName();
ClassSubject testClass = inspector.clazz(outer + "$TestClass");
assertThat(testClass, isPresent());
assertThat(testClass.uniqueMethodWithName("lambda$test$0"), isPresent());
assertThat(testClass.uniqueMethodWithName("lambda$testStatic$1"), isPresent());
- assertThat(inspector.clazz(outer + "$TestClass$1"), isPresent());
- assertThat(inspector.clazz(outer + "$TestClass$2"), isPresent());
+ assertThat(inspector.clazz(outer + "$TestClass$1MyConsumerImpl"), isPresent());
+ assertThat(inspector.clazz(outer + "$TestClass$2MyConsumerImpl"), isPresent());
}
@Test
- public void testDefault() throws Exception {
- if (parameters.getRuntime().isCf()) {
- // Run on the JVM.
- testForJvm()
- .addInnerClasses(DesugarLambdaWithLocalClass.class)
- .run(parameters.getRuntime(), TestClass.class)
- .inspect(this::checkEnclosingMethod)
- .assertSuccessWithOutputLines(
- "Hello from inside lambda$test$0", "Hello from inside lambda$testStatic$1");
- } else {
- assert parameters.getRuntime().isDex();
- // Run on Art.
- checkArtResult(
- testForD8()
- .addInnerClasses(DesugarLambdaWithLocalClass.class)
- .setMinApi(parameters.getApiLevel())
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .run(parameters.getRuntime(), TestClass.class));
- }
+ public void testDesugar() throws Exception {
+ testForDesugaring(parameters)
+ .addInnerClasses(DesugarLambdaWithLocalClass.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .inspect(this::checkEnclosingMethod)
+ .applyIf(
+ DesugarTestConfiguration::isNotDesugared,
+ r -> r.assertSuccessWithOutputLines(EXPECTED_JAVAC_RESULT))
+ .applyIf(
+ DesugarTestConfiguration::isDesugared,
+ r -> r.assertSuccessWithOutputLines(EXPECTED_DESUGARED_RESULT));
}
@Test
- public void testCfToCf() throws Exception {
- // Use D8 to desugar with Java classfile output.
- Path jar =
- testForD8(Backend.CF)
- .addInnerClasses(DesugarLambdaWithLocalClass.class)
- .setMinApi(parameters.getApiLevel())
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .writeToZip();
-
- if (parameters.getRuntime().isCf()) {
- // Run on the JVM.
- testForJvm()
- .addProgramFiles(jar)
- .run(parameters.getRuntime(), TestClass.class)
- // TODO(158752316): This should not fail.
- .assertFailureWithErrorThatThrows(InternalError.class);
- } else {
- assert parameters.getRuntime().isDex();
- // Compile to DEX without desugaring and run on Art.
- checkArtResult(
- testForD8()
- .addProgramFiles(jar)
- .setMinApi(parameters.getApiLevel())
- .disableDesugaring()
- .compile()
- .inspect(this::checkEnclosingMethodWrong)
- .run(parameters.getRuntime(), TestClass.class));
- }
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ // TODO(b/158752316, b/157700141): Disable inlining to keep the synthetic lambda methods.
+ .addOptionsModification(options -> options.enableInlining = false)
+ .addInnerClasses(DesugarLambdaWithLocalClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepRules("-keep class * { *; }")
+ // Keeping the synthetic lambda methods is currently not supported - they are
+ // forcefully unpinned. The following rule has no effect. See b/b/157700141.
+ .addKeepRules("-keep class **.*$TestClass { synthetic *; }")
+ .addKeepAttributes("InnerClasses", "EnclosingMethod")
+ .compile()
+ .inspect(this::checkEnclosingMethod)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines(
+ parameters.isCfRuntime()
+ ? EXPECTED_JAVAC_RESULT
+ : EXPECTED_DESUGARED_RESULT_R8_WITHOUT_INLINING);
}
public interface MyConsumer<T> {
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
new file mode 100644
index 0000000..e07089f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileBackport.java
@@ -0,0 +1,120 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar;
+
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.DesugarTestConfiguration;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.cf.code.CfArithmeticBinop;
+import com.android.tools.r8.cf.code.CfArithmeticBinop.Opcode;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.code.AddLong2Addr;
+import com.android.tools.r8.code.Instruction;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.DexCode;
+import com.android.tools.r8.ir.code.NumericType;
+import com.android.tools.r8.utils.AndroidApiLevel;
+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.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class DesugarToClassFileBackport extends TestBase {
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private final TestParameters parameters;
+
+ public DesugarToClassFileBackport(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private boolean isCfLAdd(CfInstruction instruction) {
+ return (instruction instanceof CfArithmeticBinop)
+ && (((CfArithmeticBinop) instruction).getOpcode() == Opcode.Add)
+ && (((CfArithmeticBinop) instruction).getType() == NumericType.LONG);
+ }
+
+ private boolean isDexAddLong(Instruction instruction) {
+ return instruction instanceof AddLong2Addr;
+ }
+
+ private boolean boxedDoubleIsFiniteInvoke(InstructionSubject instruction) {
+ System.out.println(instruction);
+ if (instruction.isInvokeStatic()) {
+ System.out.println(instruction.getMethod().qualifiedName());
+ }
+ return instruction.isInvokeStatic()
+ && instruction.getMethod().qualifiedName().equals("java.lang.Double.isFinite");
+ }
+
+ private void checkBackportingNotRequired(CodeInspector inspector) {
+ MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+ if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
+ CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
+ assertTrue(code.instructions.stream().noneMatch(this::isCfLAdd));
+ } else {
+ DexCode code = methodSubject.getProgramMethod().getDefinition().getCode().asDexCode();
+ assertTrue(Arrays.stream(code.instructions).noneMatch(this::isDexAddLong));
+ }
+ assertTrue(methodSubject.streamInstructions().anyMatch(this::boxedDoubleIsFiniteInvoke));
+ }
+
+ private void checkBackportingRequired(CodeInspector inspector) {
+ MethodSubject methodSubject = inspector.clazz(TestClass.class).uniqueMethodWithName("main");
+ if (methodSubject.getProgramMethod().getDefinition().getCode().isCfCode()) {
+ CfCode code = methodSubject.getProgramMethod().getDefinition().getCode().asCfCode();
+ assertTrue(code.instructions.stream().anyMatch(this::isCfLAdd));
+ } else {
+ DexCode code = methodSubject.getProgramMethod().getDefinition().getCode().asDexCode();
+ assertTrue(Arrays.stream(code.instructions).anyMatch(this::isDexAddLong));
+ }
+ assertTrue(methodSubject.streamInstructions().noneMatch(this::boxedDoubleIsFiniteInvoke));
+ }
+
+ private void checkBackportedIfRequired(CodeInspector inspector) {
+ if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)) {
+ checkBackportingNotRequired(inspector);
+ } else {
+ checkBackportingRequired(inspector);
+ }
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForDesugaring(parameters)
+ .addInnerClasses(DesugarToClassFileBackport.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .inspectIf(DesugarTestConfiguration::isNotDesugared, this::checkBackportingNotRequired)
+ .inspectIf(DesugarTestConfiguration::isDesugared, this::checkBackportedIfRequired)
+ .assertSuccessWithOutputLines("3", "true");
+ }
+
+ static class TestClass {
+
+ private static long getOne() {
+ return 1L;
+ }
+
+ private static long getTwo() {
+ return 2L;
+ }
+
+ public static void main(String[] args) {
+ System.out.println(Long.sum(getOne(), getTwo()));
+ System.out.println(Double.isFinite(1.0));
+ }
+ }
+}
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
new file mode 100644
index 0000000..2913fe5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
@@ -0,0 +1,167 @@
+// 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.backports;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.CoreMatchers.not;
+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.TestParametersCollection;
+import com.android.tools.r8.desugar.backports.AbstractBackportTest.MiniAssert;
+import com.android.tools.r8.synthesis.SyntheticItems;
+import com.android.tools.r8.utils.AndroidApiLevel;
+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.FoundMethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class BackportDuplicationTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Hello, world");
+
+ static final List<Class<?>> CLASSES =
+ ImmutableList.of(MiniAssert.class, TestClass.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().withDexRuntimes().withApiLevel(AndroidApiLevel.J).build();
+ }
+
+ public BackportDuplicationTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ runR8(false);
+ runR8(true);
+ }
+
+ private void runR8(boolean minify) throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(MiniAssert.class)
+ .setMinApi(parameters.getApiLevel())
+ .minification(minify)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoInternalSyntheticNames);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ List<String> run1 = getClassesAfterD8CompileAndRun();
+ List<String> run2 = getClassesAfterD8CompileAndRun();
+ assertEquals("Non deterministic synthesis", run1, run2);
+ }
+
+ private List<String> getClassesAfterD8CompileAndRun() throws Exception {
+ return testForD8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkNoInternalSyntheticNames)
+ .inspect(this::checkExpectedOutput)
+ .inspector()
+ .allClasses()
+ .stream()
+ .filter(c -> !CLASS_TYPE_NAMES.contains(c.getFinalName()))
+ .flatMap(c -> c.allMethods().stream().map(m -> m.asMethodReference().toString()))
+ .sorted()
+ .collect(Collectors.toList());
+ }
+
+ private void checkNoInternalSyntheticNames(CodeInspector inspector) {
+ inspector.forAllClasses(
+ clazz -> {
+ assertThat(
+ clazz.getFinalName(),
+ not(containsString(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)));
+ });
+ }
+
+ private void checkExpectedOutput(CodeInspector inspector) {
+ // TODO(b/158159959): Once synthetic methods can be grouped in classes this should become 1.
+ int expectedSynthesizedClasses = 3;
+ // Total number of synthetic methods should be 3 ({Boolean,Character,Long}.compare).
+ int expectedSynthesizedMethods = 3;
+ // Desugaring should add exactly one class with one desugared method.
+ assertEquals(expectedSynthesizedClasses, inspector.allClasses().size() - CLASSES.size());
+ assertThat(
+ inspector.allClasses().stream()
+ .map(ClassSubject::getOriginalName)
+ .collect(Collectors.toList()),
+ hasItems(CLASS_TYPE_NAMES.toArray()));
+ List<FoundMethodSubject> methods =
+ inspector.allClasses().stream()
+ .filter(clazz -> !CLASS_TYPE_NAMES.contains(clazz.getOriginalName()))
+ .flatMap(clazz -> clazz.allMethods().stream())
+ .collect(Collectors.toList());
+ assertEquals(expectedSynthesizedMethods, methods.size());
+ }
+
+ static class User1 {
+
+ private static void testBooleanCompare() {
+ // These 4 calls should share the same synthetic method.
+ MiniAssert.assertTrue(Boolean.compare(true, false) > 0);
+ MiniAssert.assertTrue(Boolean.compare(true, true) == 0);
+ MiniAssert.assertTrue(Boolean.compare(false, false) == 0);
+ MiniAssert.assertTrue(Boolean.compare(false, true) < 0);
+ }
+
+ private static void testCharacterCompare() {
+ // All 6 (User1 and User2) calls should share the same synthetic method.
+ MiniAssert.assertTrue(Character.compare('b', 'a') > 0);
+ MiniAssert.assertTrue(Character.compare('a', 'a') == 0);
+ MiniAssert.assertTrue(Character.compare('a', 'b') < 0);
+ }
+ }
+
+ static class User2 {
+
+ private static void testCharacterCompare() {
+ // All 6 (User1 and User2) calls should share the same synthetic method.
+ MiniAssert.assertTrue(Character.compare('y', 'x') > 0);
+ MiniAssert.assertTrue(Character.compare('x', 'x') == 0);
+ MiniAssert.assertTrue(Character.compare('x', 'y') < 0);
+ }
+
+ private static void testIntegerCompare() {
+ // These 3 calls should share the same synthetic method.
+ MiniAssert.assertTrue(Integer.compare(2, 0) > 0);
+ MiniAssert.assertTrue(Integer.compare(0, 0) == 0);
+ MiniAssert.assertTrue(Integer.compare(0, 2) < 0);
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ User1.testBooleanCompare();
+ User1.testCharacterCompare();
+ User2.testCharacterCompare();
+ User2.testIntegerCompare();
+ System.out.println("Hello, world");
+ }
+ }
+}
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
new file mode 100644
index 0000000..3be0a2c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
@@ -0,0 +1,253 @@
+// 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.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.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.desugar.backports.AbstractBackportTest.MiniAssert;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class BackportMainDexTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Hello, world");
+
+ static final List<Class<?>> CLASSES =
+ ImmutableList.of(MiniAssert.class, TestClass.class, User1.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}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withApiLevel(AndroidApiLevel.J).build();
+ }
+
+ public BackportMainDexTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private String[] getRunArgs() {
+ // Only call User1 methods on runtimes with native multidex.
+ if (parameters.isCfRuntime()
+ || parameters
+ .getRuntime()
+ .asDex()
+ .getMinApiLevel()
+ .isGreaterThanOrEqualTo(apiLevelWithNativeMultiDexSupport())) {
+ return new String[] {User1.class.getTypeName()};
+ }
+ return new String[0];
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClasses(CLASSES)
+ .run(parameters.getRuntime(), TestClass.class, getRunArgs())
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ Set<String> mainDex1 = runD8();
+ Set<String> mainDex2 = runD8();
+ assertEquals("Expected deterministic main-dex lists", mainDex1, mainDex2);
+ }
+
+ private Set<String> runD8() throws Exception {
+ MainDexConsumer mainDexConsumer = new MainDexConsumer();
+ testForD8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .setMinApi(parameters.getApiLevel())
+ .addMainDexListClasses(MiniAssert.class, TestClass.class, User2.class)
+ .setProgramConsumer(mainDexConsumer)
+ .compile()
+ .inspect(
+ inspector -> {
+ // Note: This will change if we group methods in classes, in which case we should
+ // preferable not put non-main-dex referenced methods in the main-dex group.
+ // User1 has two synthetics, one shared with User2 and one for self.
+ assertEquals(
+ 2,
+ inspector.allClasses().stream()
+ .filter(c -> c.getFinalName().startsWith(SyntheticUnderUser1))
+ .count());
+ // User2 has one synthetic as the shared call is placed in User1.
+ assertEquals(
+ 1,
+ inspector.allClasses().stream()
+ .filter(c -> c.getFinalName().startsWith(SyntheticUnderUser2))
+ .count());
+ })
+ .run(parameters.getRuntime(), TestClass.class, getRunArgs())
+ .assertSuccessWithOutput(EXPECTED);
+ checkMainDex(mainDexConsumer);
+ return mainDexConsumer.mainDexDescriptors;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ Set<String> mainDex1 = runR8();
+ if (parameters.isDexRuntime()) {
+ Set<String> mainDex2 = runR8();
+ assertEquals(mainDex1, mainDex2);
+ }
+ }
+
+ private Set<String> runR8() throws Exception {
+ MainDexConsumer mainDexConsumer = parameters.isDexRuntime() ? new MainDexConsumer() : null;
+ testForR8(parameters.getBackend())
+ .debug() // Use debug mode to force a minimal main dex.
+ .noMinification() // Disable minification so we can inspect the synthetic names.
+ .applyIf(mainDexConsumer != null, b -> b.setProgramConsumer(mainDexConsumer))
+ .addProgramClasses(CLASSES)
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(MiniAssert.class)
+ .addMainDexClassRules(MiniAssert.class, TestClass.class)
+ .addKeepMethodRules(
+ Reference.methodFromMethod(User1.class.getMethod("testBooleanCompare")),
+ Reference.methodFromMethod(User1.class.getMethod("testCharacterCompare")))
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class, getRunArgs())
+ .assertSuccessWithOutput(EXPECTED);
+ if (mainDexConsumer != null) {
+ checkMainDex(mainDexConsumer);
+ return mainDexConsumer.mainDexDescriptors;
+ }
+ return null;
+ }
+
+ private void checkMainDex(MainDexConsumer mainDexConsumer) throws Exception {
+ AndroidApp mainDexApp =
+ AndroidApp.builder()
+ .addDexProgramData(mainDexConsumer.mainDexBytes, Origin.unknown())
+ .build();
+ CodeInspector mainDexInspector = new CodeInspector(mainDexApp);
+
+ // The program classes in the main-dex list must be in main-dex.
+ assertThat(mainDexInspector.clazz(MiniAssert.class), isPresent());
+ assertThat(mainDexInspector.clazz(TestClass.class), isPresent());
+ assertThat(mainDexInspector.clazz(User2.class), isPresent());
+
+ // At least one synthetic class placed under User2 must be included in the main-dex file.
+ assertEquals(
+ 1,
+ mainDexInspector.allClasses().stream()
+ .filter(c -> c.getFinalName().startsWith(SyntheticUnderUser2))
+ .count());
+
+ // Minimal main dex should only include one of the User1 synthetics.
+ assertThat(mainDexInspector.clazz(User1.class), not(isPresent()));
+ assertEquals(
+ 1,
+ mainDexInspector.allClasses().stream()
+ .filter(c -> c.getFinalName().startsWith(SyntheticUnderUser1))
+ .count());
+ assertThat(mainDexInspector.clazz(SyntheticUnderUser1), not(isPresent()));
+ }
+
+ static class User1 {
+
+ public static void testBooleanCompare() {
+ // These 4 calls should share the same synthetic method.
+ MiniAssert.assertTrue(Boolean.compare(true, false) > 0);
+ MiniAssert.assertTrue(Boolean.compare(true, true) == 0);
+ MiniAssert.assertTrue(Boolean.compare(false, false) == 0);
+ MiniAssert.assertTrue(Boolean.compare(false, true) < 0);
+ }
+
+ public static void testCharacterCompare() {
+ // All 6 (User1 and User2) calls should share the same synthetic method.
+ MiniAssert.assertTrue(Character.compare('b', 'a') > 0);
+ MiniAssert.assertTrue(Character.compare('a', 'a') == 0);
+ MiniAssert.assertTrue(Character.compare('a', 'b') < 0);
+ }
+ }
+
+ static class User2 {
+
+ public static void testCharacterCompare() {
+ // All 6 (User1 and User2) calls should share the same synthetic method.
+ MiniAssert.assertTrue(Character.compare('y', 'x') > 0);
+ MiniAssert.assertTrue(Character.compare('x', 'x') == 0);
+ MiniAssert.assertTrue(Character.compare('x', 'y') < 0);
+ }
+
+ public static void testIntegerCompare() {
+ // These 3 calls should share the same synthetic method.
+ MiniAssert.assertTrue(Integer.compare(2, 0) > 0);
+ MiniAssert.assertTrue(Integer.compare(0, 0) == 0);
+ MiniAssert.assertTrue(Integer.compare(0, 2) < 0);
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) throws Exception {
+ if (args.length == 1) {
+ // Reflectively call the backports on User1 which is not in the main-dex list.
+ Class<?> user1 = Class.forName(args[0]);
+ user1.getMethod("testBooleanCompare").invoke(user1);
+ user1.getMethod("testCharacterCompare").invoke(user1);
+ }
+ User2.testCharacterCompare();
+ User2.testIntegerCompare();
+ System.out.println("Hello, world");
+ }
+ }
+
+ private static class MainDexConsumer implements DexIndexedConsumer {
+
+ byte[] mainDexBytes;
+ Set<String> mainDexDescriptors;
+
+ @Override
+ public void accept(
+ int fileIndex, ByteDataView data, Set<String> descriptors, DiagnosticsHandler handler) {
+ if (fileIndex == 0) {
+ assertNull(mainDexBytes);
+ assertNull(mainDexDescriptors);
+ mainDexBytes = data.copyByteData();
+ mainDexDescriptors = descriptors;
+ }
+ }
+
+ @Override
+ public void finished(DiagnosticsHandler handler) {
+ assertNotNull(mainDexBytes);
+ assertNotNull(mainDexDescriptors);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/DesugarStaticBackportsOnly.java b/src/test/java/com/android/tools/r8/desugar/backports/DesugarStaticBackportsOnly.java
index cd6d160..77e088c 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/DesugarStaticBackportsOnly.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/DesugarStaticBackportsOnly.java
@@ -17,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.SyntheticItems;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.InternalOptions.DesugarState;
import com.android.tools.r8.utils.StringUtils;
@@ -55,7 +56,7 @@
instructionSubject.isInvokeStatic()
&& instructionSubject
.toString()
- .contains("$r8$backportedMethods$utility$Long$1$hashCode")));
+ .contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)));
assertEquals(
parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N),
classSubject
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryContentTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryContentTest.java
index 1b46018..d99b31f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryContentTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryContentTest.java
@@ -6,6 +6,7 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertFalse;
@@ -84,7 +85,7 @@
}
private void assertCorrect(CodeInspector inspector) {
- inspector.allClasses().forEach(clazz -> assertTrue(clazz.getOriginalName().startsWith("j$.")));
+ inspector.allClasses().forEach(clazz -> assertThat(clazz.getOriginalName(), startsWith("j$.")));
assertThat(inspector.clazz("j$.time.Clock"), isPresent());
// Above N the following classes are removed instead of being desugared.
if (parameters.getApiLevel().getLevel() >= AndroidApiLevel.N.getLevel()) {
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodTest.java
index adaa55f..b15c928 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.desugaring.interfacemethods;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
@@ -23,7 +23,7 @@
.addInnerClasses(InvokeSuperInDefaultInterfaceMethodTest.class)
.addKeepMainRule(TestClass.class)
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(AndroidApiLevel.M)
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput);
@@ -37,7 +37,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
default void m() {
@@ -45,7 +45,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends I {
@Override
@@ -55,7 +55,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface K extends I {
// Intentionally does not override I.m().
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterInlineRegression.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterInlineRegression.java
index 3e3a02c..278d99c 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterInlineRegression.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterInlineRegression.java
@@ -13,7 +13,7 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
@@ -56,7 +56,8 @@
assertThat(clazz.uniqueMethodWithName("getFromFeature"), not(isPresent()));
};
Consumer<R8FullTestBuilder> configurator =
- r8FullTestBuilder -> r8FullTestBuilder.enableMergeAnnotations().noMinification();
+ r8FullTestBuilder ->
+ r8FullTestBuilder.enableNoVerticalClassMergingAnnotations().noMinification();
ProcessResult processResult =
testDexSplitter(
parameters,
@@ -75,7 +76,8 @@
public void testOnR8Splitter() throws IOException, CompilationFailedException {
assumeTrue(parameters.isDexRuntime());
Consumer<R8FullTestBuilder> configurator =
- r8FullTestBuilder -> r8FullTestBuilder.enableMergeAnnotations().noMinification();
+ r8FullTestBuilder ->
+ r8FullTestBuilder.enableNoVerticalClassMergingAnnotations().noMinification();
ProcessResult processResult =
testR8Splitter(
parameters,
@@ -89,7 +91,7 @@
assertEquals(processResult.stdout, StringUtils.lines("42"));
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class BaseSuperClass implements RunInterface {
@Override
public void run() {
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 5a0fd21..c9dd274 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterMergeRegression.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
@@ -60,7 +60,7 @@
Consumer<R8FullTestBuilder> configurator =
r8FullTestBuilder ->
r8FullTestBuilder
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.noMinification()
.addOptionsModification(o -> o.testing.deterministicSortingBasedOnDexType = true);
@@ -82,7 +82,8 @@
public void testOnR8Splitter() throws IOException, CompilationFailedException {
assumeTrue(parameters.isDexRuntime());
Consumer<R8FullTestBuilder> configurator =
- r8FullTestBuilder -> r8FullTestBuilder.enableMergeAnnotations().noMinification();
+ r8FullTestBuilder ->
+ r8FullTestBuilder.enableNoVerticalClassMergingAnnotations().noMinification();
ProcessResult processResult =
testR8Splitter(
parameters,
@@ -96,7 +97,7 @@
assertTrue(processResult.stdout.equals(StringUtils.lines("42", "foobar")));
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class BaseClass implements RunInterface {
@Override
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitServiceLoaderTest.java b/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitServiceLoaderTest.java
index c290f26..9e116da 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitServiceLoaderTest.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitServiceLoaderTest.java
@@ -5,8 +5,11 @@
package com.android.tools.r8.dexsplitter;
import static com.android.tools.r8.rewrite.ServiceLoaderRewritingTest.getServiceLoaderLoads;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.DataEntryResource;
import com.android.tools.r8.R8TestRunResult;
@@ -103,45 +106,31 @@
@Test
public void testR8AllLoaded() throws Exception {
- Path base = temp.newFile("base.zip").toPath();
- Path feature1Path = temp.newFile("feature1.zip").toPath();
- Path feature2Path = temp.newFile("feature2.zip").toPath();
R8TestRunResult runResult =
testForR8(parameters.getBackend())
.addProgramClasses(Base.class, I.class)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(Base.class)
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder,
- feature1Path,
- temp,
- ImmutableList.of(
- new Pair<>(
- "META-INF/services/" + I.class.getTypeName(),
- StringUtils.lines(Feature1I.class.getTypeName()))),
- true,
- Feature1I.class))
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder,
- feature2Path,
- temp,
- ImmutableList.of(
- new Pair<>(
- "META-INF/services/" + I.class.getTypeName(),
- StringUtils.lines(Feature2I.class.getTypeName()))),
- true,
- Feature2I.class))
+ .addFeatureSplitWithResources(
+ ImmutableList.of(
+ new Pair<>(
+ "META-INF/services/" + I.class.getTypeName(),
+ StringUtils.lines(Feature1I.class.getTypeName()))),
+ Feature1I.class)
+ .addFeatureSplitWithResources(
+ ImmutableList.of(
+ new Pair<>(
+ "META-INF/services/" + I.class.getTypeName(),
+ StringUtils.lines(Feature2I.class.getTypeName()))),
+ Feature2I.class)
.compile()
.inspect(
- inspector -> {
- assertEquals(1, getServiceLoaderLoads(inspector, Base.class));
- })
- .writeToZip(base)
- .addRunClasspathFiles(feature1Path, feature2Path)
+ baseInspector -> assertEquals(1, getServiceLoaderLoads(baseInspector, Base.class)),
+ feature1Inspector ->
+ assertThat(feature1Inspector.clazz(Feature1I.class), isPresent()),
+ feature2Inspector ->
+ assertThat(feature2Inspector.clazz(Feature2I.class), isPresent()))
+ .addFeatureSplitsToRunClasspathFiles()
.run(parameters.getRuntime(), Base.class);
// TODO(b/160888348): This is failing on 7.0
if (parameters.getRuntime().isDex()
@@ -154,39 +143,29 @@
@Test
public void testR8WithServiceFileInSeparateFeature() throws Exception {
- Path base = temp.newFile("base.zip").toPath();
- Path feature1Path = temp.newFile("feature1.zip").toPath();
- Path feature2Path = temp.newFile("feature2.zip").toPath();
- Path feature3Path = temp.newFile("feature3.zip").toPath();
R8TestRunResult runResult =
testForR8(parameters.getBackend())
.addProgramClasses(Base.class, I.class)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(Base.class)
- .addFeatureSplit(
- builder -> simpleSplitProvider(builder, feature1Path, temp, Feature1I.class))
- .addFeatureSplit(
- builder -> simpleSplitProvider(builder, feature2Path, temp, Feature2I.class))
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder,
- feature3Path,
- temp,
- ImmutableList.of(
- new Pair<>(
- "META-INF/services/" + I.class.getTypeName(),
- StringUtils.lines(
- Feature1I.class.getTypeName(), Feature2I.class.getTypeName()))),
- true,
- Feature3Dummy.class))
+ .addFeatureSplit(Feature1I.class)
+ .addFeatureSplit(Feature2I.class)
+ .addFeatureSplitWithResources(
+ ImmutableList.of(
+ new Pair<>(
+ "META-INF/services/" + I.class.getTypeName(),
+ StringUtils.lines(
+ Feature1I.class.getTypeName(), Feature2I.class.getTypeName()))),
+ Feature3Dummy.class)
.compile()
.inspect(
- inspector -> {
- assertEquals(1, getServiceLoaderLoads(inspector, Base.class));
- })
- .writeToZip(base)
- .addRunClasspathFiles(feature1Path, feature2Path, feature3Path)
+ baseInspector -> assertEquals(1, getServiceLoaderLoads(baseInspector, Base.class)),
+ feature1Inspector ->
+ assertThat(feature1Inspector.clazz(Feature1I.class), isPresent()),
+ feature2Inspector ->
+ assertThat(feature2Inspector.clazz(Feature2I.class), isPresent()),
+ feature3Inspector -> assertTrue(feature3Inspector.allClasses().isEmpty()))
+ .addFeatureSplitsToRunClasspathFiles()
.run(parameters.getRuntime(), Base.class);
// TODO(b/160888348): This is failing on 7.0
if (parameters.getRuntime().isDex()
@@ -199,44 +178,28 @@
@Test
public void testR8OnlyFeature2() throws Exception {
- Path base = temp.newFile("base.zip").toPath();
- Path feature1Path = temp.newFile("feature1.zip").toPath();
- Path feature2Path = temp.newFile("feature2.zip").toPath();
testForR8(parameters.getBackend())
.addProgramClasses(Base.class, I.class)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(Base.class)
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder,
- feature1Path,
- temp,
- ImmutableList.of(
- new Pair<>(
- "META-INF/services/" + I.class.getTypeName(),
- StringUtils.lines(Feature1I.class.getTypeName()))),
- true,
- Feature1I.class))
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder,
- feature2Path,
- temp,
- ImmutableList.of(
- new Pair<>(
- "META-INF/services/" + I.class.getTypeName(),
- StringUtils.lines(Feature2I.class.getTypeName()))),
- true,
- Feature2I.class))
+ .addFeatureSplitWithResources(
+ ImmutableList.of(
+ new Pair<>(
+ "META-INF/services/" + I.class.getTypeName(),
+ StringUtils.lines(Feature1I.class.getTypeName()))),
+ Feature1I.class)
+ .addFeatureSplitWithResources(
+ ImmutableList.of(
+ new Pair<>(
+ "META-INF/services/" + I.class.getTypeName(),
+ StringUtils.lines(Feature2I.class.getTypeName()))),
+ Feature2I.class)
.compile()
.inspect(
- inspector -> {
- assertEquals(1, getServiceLoaderLoads(inspector, Base.class));
- })
- .writeToZip(base)
- .addRunClasspathFiles(feature2Path)
+ baseInspector -> assertEquals(1, getServiceLoaderLoads(baseInspector, Base.class)),
+ feature1Inspector -> assertThat(feature1Inspector.clazz(Feature1I.class), isPresent()),
+ feature2Inspector -> assertThat(feature2Inspector.clazz(Feature2I.class), isPresent()))
+ .apply(compileResult -> compileResult.addRunClasspathFiles(compileResult.getFeature(1)))
.run(parameters.getRuntime(), Base.class)
// TODO(b/160889305): This should work.
.assertFailureWithErrorThatMatches(containsString("java.lang.ClassNotFoundException"));
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitTest.java b/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitTest.java
index 60477b6..b5940d4 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitTest.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/R8FeatureSplitTest.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.ExtractMarker;
import com.android.tools.r8.FeatureSplit;
+import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.ResourceException;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -131,12 +132,11 @@
.setMinApi(parameters.getApiLevel())
.addFeatureSplit(
builder ->
- splitWithNonJavaFile(
- builder, feature1Path, temp, nonJavaFiles, true, FeatureClass.class))
+ splitWithNonJavaFile(builder, feature1Path, temp, nonJavaFiles, FeatureClass.class))
.addFeatureSplit(
builder ->
splitWithNonJavaFile(
- builder, feature2Path, temp, nonJavaFiles, true, FeatureClass2.class))
+ builder, feature2Path, temp, nonJavaFiles, FeatureClass2.class))
.addKeepAllClassesRule()
.compile()
.writeToZip(basePath);
@@ -158,32 +158,23 @@
@Test
public void testAdaptResourceContentInSplits() throws IOException, CompilationFailedException {
- Path basePath = temp.newFile("base.zip").toPath();
- Path feature1Path = temp.newFile("feature1.zip").toPath();
- Path feature2Path = temp.newFile("feature2.zip").toPath();
// Make the content of the data resource be class names
Collection<Pair<String, String>> nonJavaFiles =
ImmutableList.of(
new Pair<>(FeatureClass.class.getName(), FeatureClass.class.getName()),
new Pair<>(FeatureClass2.class.getName(), FeatureClass2.class.getName()));
- testForR8(parameters.getBackend())
- .addProgramClasses(BaseClass.class, RunInterface.class, SplitRunner.class)
- .setMinApi(parameters.getApiLevel())
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder, feature1Path, temp, nonJavaFiles, false, FeatureClass.class))
- .addFeatureSplit(
- builder ->
- splitWithNonJavaFile(
- builder, feature2Path, temp, nonJavaFiles, false, FeatureClass2.class))
- .addKeepClassRulesWithAllowObfuscation(
- BaseClass.class, FeatureClass.class, FeatureClass2.class)
- .addKeepRules("-adaptresourcefilecontents")
- .compile()
- .writeToZip(basePath);
- for (Path feature : ImmutableList.of(feature1Path, feature2Path)) {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(BaseClass.class, RunInterface.class, SplitRunner.class)
+ .setMinApi(parameters.getApiLevel())
+ .addFeatureSplitWithResources(nonJavaFiles, FeatureClass.class)
+ .addFeatureSplitWithResources(nonJavaFiles, FeatureClass2.class)
+ .addKeepClassRulesWithAllowObfuscation(
+ BaseClass.class, FeatureClass.class, FeatureClass2.class)
+ .addKeepRules("-adaptresourcefilecontents")
+ .compile();
+ for (Path feature : compileResult.getFeatures()) {
ZipFile zipFile = new ZipFile(feature.toFile());
for (Pair<String, String> nonJavaFile : nonJavaFiles) {
ZipEntry entry = zipFile.getEntry(nonJavaFile.getFirst());
@@ -192,7 +183,7 @@
assertNotEquals(content, nonJavaFile.getSecond());
}
}
- ZipFile zipFile = new ZipFile(basePath.toFile());
+ ZipFile zipFile = new ZipFile(compileResult.writeToZip().toFile());
for (Pair<String, String> nonJavaFile : nonJavaFiles) {
ZipEntry entry = zipFile.getEntry(nonJavaFile.getFirst());
assertNull(entry);
@@ -259,20 +250,17 @@
public CompiledWithFeature invoke() throws IOException, CompilationFailedException {
- basePath = temp.newFile("base.zip").toPath();
- feature1Path = temp.newFile("feature1.zip").toPath();
- feature2Path = temp.newFile("feature2.zip").toPath();
-
- testForR8(parameters.getBackend())
- .addProgramClasses(BaseClass.class, RunInterface.class, SplitRunner.class)
- .setMinApi(parameters.getApiLevel())
- .addFeatureSplit(
- builder -> simpleSplitProvider(builder, feature1Path, temp, FeatureClass.class))
- .addFeatureSplit(
- builder -> simpleSplitProvider(builder, feature2Path, temp, FeatureClass2.class))
- .addKeepAllClassesRule()
- .compile()
- .writeToZip(basePath);
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(BaseClass.class, RunInterface.class, SplitRunner.class)
+ .setMinApi(parameters.getApiLevel())
+ .addFeatureSplit(FeatureClass.class)
+ .addFeatureSplit(FeatureClass2.class)
+ .addKeepAllClassesRule()
+ .compile();
+ basePath = compileResult.writeToZip();
+ feature1Path = compileResult.getFeature(0);
+ feature2Path = compileResult.getFeature(1);
return this;
}
}
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
index def7782..46ac75d 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/R8SplitterInlineToFeature.java
@@ -10,7 +10,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assume.assumeTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
@@ -50,7 +50,8 @@
public void testInlining() throws Exception {
assumeTrue(parameters.isDexRuntime());
Consumer<R8FullTestBuilder> configurator =
- r8FullTestBuilder -> r8FullTestBuilder.enableMergeAnnotations().noMinification();
+ r8FullTestBuilder ->
+ r8FullTestBuilder.enableNoVerticalClassMergingAnnotations().noMinification();
ThrowingConsumer<R8TestCompileResult, Exception> ensureInlined =
r8TestCompileResult -> {
// Ensure that isEarly from BaseUtilClass is inlined into the feature
@@ -70,7 +71,7 @@
assertEquals(processResult.stdout, StringUtils.lines("42"));
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class BaseSuperClass implements RunInterface {
@Override
public void run() {
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 816ed12..c41a1d1 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/SplitterTestBase.java
@@ -1,6 +1,5 @@
package com.android.tools.r8.dexsplitter;
-import static junit.framework.TestCase.assertTrue;
import static junit.framework.TestCase.fail;
import static org.junit.Assume.assumeTrue;
@@ -19,7 +18,6 @@
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.dexsplitter.DexSplitter.Options;
import com.android.tools.r8.utils.ArchiveResourceProvider;
-import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.ThrowingConsumer;
import com.android.tools.r8.utils.ZipUtils;
@@ -35,7 +33,6 @@
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
-import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
@@ -53,7 +50,7 @@
Path outputPath,
TemporaryFolder temp,
Collection<Class<?>> classes) {
- addConsumers(builder, outputPath, temp, null, true, classes);
+ addConsumers(builder, outputPath, temp, null, classes);
return builder.build();
}
@@ -62,9 +59,7 @@
Path outputPath,
TemporaryFolder temp,
Collection<Pair<String, String>> nonJavaResources,
- boolean ensureClassesInOutput,
Collection<Class<?>> classes) {
- List<String> classNames = classes.stream().map(Class::getName).collect(Collectors.toList());
Path featureJar;
try {
featureJar = temp.newFolder().toPath().resolve("feature.jar");
@@ -109,26 +104,18 @@
ByteDataView data,
Set<String> descriptors,
DiagnosticsHandler handler) {
- if (ensureClassesInOutput) {
- for (String descriptor : descriptors) {
- assertTrue(
- classNames.contains(DescriptorUtils.descriptorToJavaType(descriptor)));
- }
- }
super.accept(fileIndex, data, descriptors, handler);
}
});
}
- static FeatureSplit splitWithNonJavaFile(
+ public static FeatureSplit splitWithNonJavaFile(
FeatureSplit.Builder builder,
Path outputPath,
TemporaryFolder temp,
Collection<Pair<String, String>> nonJavaFiles,
- boolean ensureClassesInOutput,
Class<?>... classes) {
- addConsumers(
- builder, outputPath, temp, nonJavaFiles, ensureClassesInOutput, Arrays.asList(classes));
+ addConsumers(builder, outputPath, temp, nonJavaFiles, Arrays.asList(classes));
return builder.build();
}
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 6483aee..20362c3 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
@@ -5,8 +5,8 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
@@ -51,7 +51,7 @@
.addKeepRuntimeVisibleAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
.allowDiagnosticInfoMessages()
.setMinApi(parameters.getApiLevel())
@@ -83,7 +83,7 @@
MyEnumArray[] myEnumArray();
}
- @NeverMerge
+ @NoVerticalClassMerging
@Retention(RetentionPolicy.RUNTIME)
@interface ClassAnnotation {}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
index d6dda57..74ee98c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
import java.util.List;
@@ -43,7 +43,7 @@
.addKeepMainRule(classToTest)
.addKeepRules(enumKeepRules.getKeepRules())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
.allowDiagnosticInfoMessages()
@@ -69,7 +69,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoStaticClassMerging
static class OtherClass {
static {
Switch.otherClassInit = true;
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
index d1e5b4a..e9a7e5d 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.enumunboxing.examplelib1.JavaLibrary1;
-import com.android.tools.r8.ir.optimize.enums.EnumUnboxingRewriter;
+import com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -93,7 +93,7 @@
.anyMatch(
c ->
c.getOriginalName()
- .contains(EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_CLASS_NAME)));
+ .contains(UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)));
}
static class App {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
index 49fc118..227ce07 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.enumunboxing.examplelib1.JavaLibrary1;
import com.android.tools.r8.enumunboxing.examplelib2.JavaLibrary2;
-import com.android.tools.r8.ir.optimize.enums.EnumUnboxingRewriter;
+import com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -97,7 +97,7 @@
.anyMatch(
c ->
c.getOriginalName()
- .contains(EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_CLASS_NAME)));
+ .contains(UnboxedEnumMemberRelocator.ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)));
}
static class App {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
index fba8006..7311ab2 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
@@ -55,7 +55,7 @@
.addKeepMainRules(SUCCESSES)
.addKeepMainRules(FAILURES)
.noMinification()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepRules(enumKeepRules.getKeepRules())
@@ -106,7 +106,7 @@
C
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {}
}
@@ -124,7 +124,7 @@
C
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
@NeverInline
default int ordinal() {
@@ -153,7 +153,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
@NeverInline
default int method() {
@@ -176,7 +176,7 @@
C
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
@NeverInline
default int method() {
@@ -205,7 +205,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
int method();
}
@@ -225,7 +225,7 @@
C
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
@NeverInline
default int method() {
@@ -259,7 +259,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
@NeverInline
default int method() {
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 9848767..d191976 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -8,7 +8,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -23,10 +23,10 @@
@RunWith(Parameterized.class)
public class MissingClassThrowingTest extends TestBase {
- @NeverMerge
+ @NoStaticClassMerging
public static class MissingException extends Exception {}
- @NeverMerge
+ @NoStaticClassMerging
public static class Program {
public static final String EXPECTED_OUTPUT = "Hello world!";
@@ -72,11 +72,9 @@
.noMinification()
.noTreeShaking()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.debug()
- .addKeepRules(
- "-keep class ** { *; }",
- "-keepattributes *")
+ .addKeepRules("-keep class ** { *; }", "-keepattributes *")
.compile()
.addRunClasspathClasses(MissingException.class)
.run(parameters.getRuntime(), Program.class)
diff --git a/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
index 090844e..4be7975 100644
--- a/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -64,7 +64,7 @@
.addProgramClasses(I.class)
.addProgramClassFileData(getClassWithTransformedInvoked())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(Main.class)
.run(parameters.getRuntime(), Main.class);
}
@@ -77,7 +77,7 @@
.addProgramClasses(I.class)
.addProgramClassFileData(getClassWithTransformedInvoked())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(o -> o.testing.allowInvokeErrors = true)
.addKeepMainRule(Main.class)
.run(parameters.getRuntime(), Main.class);
@@ -104,7 +104,7 @@
.transform();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
index c4d321a..dbbf99a 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/PutObjectWithFinalizeTest.java
@@ -10,7 +10,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -47,7 +47,7 @@
// The class staticizer does not consider the finalize() method.
.addOptionsModification(options -> options.enableClassStaticizer = false)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(
@@ -136,7 +136,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@Override
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 f46650f..6d3c6cb 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.D8TestCompileResult;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -70,7 +70,7 @@
.addKeepAllClassesRule()
.addOptionsModification(options -> options.testing.allowTypeErrors = allowTypeErrors)
.allowDiagnosticWarningMessages()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compileWithExpectedDiagnostics(
diagnostics -> {
@@ -133,7 +133,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
abstract static class A {}
static class ASub1 extends A {}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
index 0eb5fab..684b669 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
@@ -11,8 +11,8 @@
import com.android.tools.r8.D8TestRunResult;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.SingleTestRunResult;
import com.android.tools.r8.TestBase;
@@ -31,7 +31,7 @@
import org.junit.runners.Parameterized;
class AlwaysThrowNullTestClass {
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {
Object dead;
@@ -239,7 +239,7 @@
R8TestRunResult result =
testForR8(parameters.getBackend())
.addProgramClassesAndInnerClasses(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
.addKeepMainRule(MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/DefaultInterfaceIssue143628636Test.java b/src/test/java/com/android/tools/r8/ir/optimize/DefaultInterfaceIssue143628636Test.java
index 94de4ba..50fbd54 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/DefaultInterfaceIssue143628636Test.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/DefaultInterfaceIssue143628636Test.java
@@ -5,7 +5,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,7 +43,7 @@
testForR8(parameters.getBackend())
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addInnerClasses(DefaultInterfaceIssue143628636Test.class)
.addKeepMainRule(TestClass.class)
.addKeepClassRules(I.class)
@@ -52,7 +52,7 @@
.assertSuccessWithOutputLines("2", "5");
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public interface A {
@@ -76,7 +76,7 @@
// Make sure this class and the call to h() are never eliminated. It is the *partial* info
// propagated from h() to f() that results in incorrect call-site optimization info.
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public static class B implements A {
public final int x;
@@ -99,7 +99,7 @@
// Make sure this class and the call to h() are never eliminated. It is the *missing* info
// propagated from h() to f() that results in incorrect call-site optimization info.
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public static class C implements I {
public final I i;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
index 626f771..964848a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullParamTest.java
@@ -226,7 +226,7 @@
.addOptionsModification(this::disableDevirtualization)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations());
+ .enableNoVerticalClassMergingAnnotations());
ClassSubject mainSubject = inspector.clazz(NonNullParamAfterInvokeInterface.class);
assertThat(mainSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java
index 0c158b9..a36a63c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/HashCodeTest.java
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize.callsites;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -32,10 +32,11 @@
testForR8(parameters.getBackend())
.addInnerClasses(HashCodeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .enableNoVerticalClassMergingAnnotations()
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("10");
@@ -55,7 +56,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@Override
public int hashCode() {
@@ -63,7 +64,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
@Override
public int hashCode() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
index 2edbb0b..d6bcd2b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeInterfaceWithRefinedReceiverTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeInterfaceWithRefinedReceiverTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -108,7 +108,7 @@
void m(Object arg);
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class B implements I {
@NeverInline
@@ -149,7 +149,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class C implements I {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
index e36941d..43f777d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/InvokeVirtualWithRefinedReceiverTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualWithRefinedReceiverTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -105,7 +105,7 @@
abstract void m(Object arg);
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class B extends A {
@NeverInline
@@ -146,7 +146,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class C extends A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromSiblingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromSiblingTest.java
index fb3bc2e..429b5a2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromSiblingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromSiblingTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -36,7 +36,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(options -> options.enableUnusedInterfaceRemoval = false)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -66,7 +66,7 @@
interface J extends I {}
- @NeverMerge
+ @NoVerticalClassMerging
static class A implements I {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
index 75dd8a8..7c2eeee 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfaceNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeInterfaceNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -80,7 +80,7 @@
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
void m(String arg);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
index 3ae302a..7be71b2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -91,7 +91,7 @@
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
index 91d181e..5b3b309 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeVirtualPositiveTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -45,7 +45,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualPositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -92,7 +92,7 @@
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
index e131be5..51175f8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectPositiveTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeDirectPositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -87,8 +87,9 @@
assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {}
+
static class Sub1 extends Base {}
static class Sub2 extends Base {}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
index 4b4c534..31e6779 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfaceNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeInterfaceNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -96,7 +96,7 @@
static class Sub1 extends Base {}
static class Sub2 extends Base {}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
void m(Base arg);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
index bda0a3a..4091161 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeInterfacePositiveTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeInterfacePositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -97,8 +97,9 @@
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {}
+
static class Sub1 extends Base {}
static class Sub2 extends Base {}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
index 6ea0888..ff19f58 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticPositiveTest.java
@@ -8,7 +8,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,11 +43,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeStaticPositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("Sub1")
@@ -81,8 +82,9 @@
assertTrue(test.streamInstructions().noneMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {}
+
static class Sub1 extends Base {}
static class Sub2 extends Base {}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
index 51145b2..39bfa4c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -104,7 +104,7 @@
static class Sub1 extends Base {}
static class Sub2 extends Base {}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
index 8c17c3a..2595df5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeVirtualPositiveTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualPositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -95,12 +95,13 @@
assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {}
+
static class Sub1 extends Base {}
static class Sub2 extends Base {}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
index 79a49e0..bc9f10c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfaceNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeInterfaceNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -84,7 +84,7 @@
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
void m(Object arg);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
index d2181d5..f46869d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualCascadeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,7 +41,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualCascadeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -68,7 +68,7 @@
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
index 26bb65e..544cf86 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualNegativeTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualNegativeTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -92,7 +92,7 @@
assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
index 00601a9..2cff135 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeVirtualPositiveTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualPositiveTest.class)
.addKeepMainRule(MAIN)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addOptionsModification(
@@ -91,7 +91,7 @@
assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java
index 47ae6be..2765bb2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java
@@ -8,7 +8,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -26,9 +26,8 @@
class LibraryClass {
}
-@NeverMerge
-class ProgramClass1 extends LibraryClass {
-}
+@NoVerticalClassMerging
+class ProgramClass1 extends LibraryClass {}
class ProgramSubClass extends ProgramClass1 {
}
@@ -114,7 +113,7 @@
.addProgramClasses(ProgramClass1.class, ProgramClass2.class, ProgramSubClass.class, MAIN)
.addKeepMainRule(MAIN)
.noMinification()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(InternalOptions::disableNameReflectionOptimization)
.setMinApi(parameters.getRuntime())
.compile()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
index 73d694e..d158c7d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,7 +41,7 @@
.addInnerClasses(BuilderWithInheritanceTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput("42")
@@ -70,7 +70,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class BuilderBase {
protected int f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithMethodOnParentClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithMethodOnParentClassTest.java
index 7076755..a8098cb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithMethodOnParentClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithMethodOnParentClassTest.java
@@ -9,8 +9,8 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -40,7 +40,7 @@
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -60,7 +60,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class BuilderBase {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java
index 596c9e5..e603587 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.addInnerClasses(ClassInlineInstanceInitializerWithAccessibleStaticGetTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -61,7 +61,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class CandidateBase {
final String f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java
index c0f45d4..29a3cb6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.addInnerClasses(ClassInlineInstanceInitializerWithCheckCastTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -59,7 +59,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class CandidateBase {
final String f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java
index 912374d..a39dd98 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.addInnerClasses(ClassInlineInstanceInitializerWithIfTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -59,7 +59,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class CandidateBase {
final String f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
index 34e9d5d..26e44d5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
@@ -41,7 +41,7 @@
ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java
index c86e0fc..d1e2e54 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java
@@ -8,8 +8,8 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -39,7 +39,7 @@
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -59,7 +59,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class CandidateBase {
CandidateBase() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java
index 43e2998..a0429d1 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.addInnerClasses(ClassInlineInstanceInitializerWithInstanceOfTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -59,7 +59,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class CandidateBase {
final boolean f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
index 4ccc742..16aac95 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineKeepMethodTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -32,7 +32,7 @@
private final TestParameters parameters;
private static final String EXPECTED_OUTPUT = "Hello world";
- @NeverMerge
+ @NoVerticalClassMerging
public static class ShouldBeKept {
@NeverInline
@@ -61,15 +61,16 @@
@Test
public void testIsKeptWithName()
throws ExecutionException, CompilationFailedException, IOException {
- CodeInspector inspector = testForR8(parameters.getBackend())
- .addInnerClasses(ClassInlineKeepMethodTest.class)
- .addKeepMainRule(Keeper.class)
- .addKeepClassAndMembersRules(ShouldBeKept.class)
- .enableInliningAnnotations()
- .enableMergeAnnotations()
- .run(parameters.getRuntime(), Keeper.class)
- .assertSuccessWithOutput(EXPECTED_OUTPUT)
- .inspector();
+ CodeInspector inspector =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineKeepMethodTest.class)
+ .addKeepMainRule(Keeper.class)
+ .addKeepClassAndMembersRules(ShouldBeKept.class)
+ .enableInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .run(parameters.getRuntime(), Keeper.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT)
+ .inspector();
ClassSubject clazz = inspector.clazz(Keeper.class);
assertThat(clazz, isPresent());
MethodSubject main = clazz.uniqueMethodWithName("main");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
index b8b159c..13a5fcc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertNotEquals;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -48,7 +48,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(options -> options.enableClassInlining = enableClassInlining)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::verifyCandidateIsClassInlined)
@@ -83,10 +83,10 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {}
static class C extends B {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningOracleTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningOracleTest.java
index bd87a92..e0bd65e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningOracleTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningOracleTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.KeepUnusedArguments;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -50,7 +50,7 @@
enableInvokeSuperToInvokeVirtualRewriting)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableUnusedArgumentAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -78,7 +78,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class HelperBase {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningWithImpreciseReceiverTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningWithImpreciseReceiverTypeTest.java
index cfdfcda..973ae87 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningWithImpreciseReceiverTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliningWithImpreciseReceiverTypeTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.ir.optimize.classinliner;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -33,7 +33,7 @@
.addInnerClasses(ClassInliningWithImpreciseReceiverTypeTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
@@ -51,7 +51,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
abstract static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java
index 2062667..6f5ab71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapeFromParentConstructorTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -38,7 +38,7 @@
.addInnerClasses(EscapeFromParentConstructorTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -60,7 +60,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class BuilderBase {
String greeting;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java
index 50eeac4..cc0734b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java
@@ -4,11 +4,11 @@
package com.android.tools.r8.ir.optimize.classinliner.testclasses;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
public class ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses {
- @NeverMerge
+ @NoStaticClassMerging
public static class CandidateBase {
public final String f;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizerNonNullRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizerNonNullRewritingTest.java
index 61d5cf3..28a973c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizerNonNullRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/DevirtualizerNonNullRewritingTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.ir.optimize.devirtualize;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -46,7 +46,7 @@
.addInnerClasses(DevirtualizerNonNullRewritingTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(EXPECTED_OUTPUT);
@@ -78,14 +78,14 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Interface {
@NeverInline
void method();
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTest.java
index 80a6d8d..d4e3985 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InterfaceRenewalInLoopDebugTest.java
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize.devirtualize;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import java.util.ArrayList;
import java.util.List;
@@ -11,7 +11,7 @@
void foo();
}
-@NeverMerge
+@NoVerticalClassMerging
class OneUniqueImplementer implements TestInterface {
String boo;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
index a85906b..98628aa 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeSuperToInvokeVirtualTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -42,7 +42,7 @@
.addInnerClasses(InvokeSuperToInvokeVirtualTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -89,7 +89,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java
index 9bc40d7..47dc21e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java
@@ -5,7 +5,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -39,14 +39,14 @@
.addKeepRules("-keepclassmembers class * { void fooCaller(...); }")
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(EXPECTED);
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
int x;
@NeverInline
@@ -57,7 +57,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
// B#foo is invoked twice by other wrappers in the same class.
@Override
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
index d0d52ec..b2fe085 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineNonReboundFieldTest.java
@@ -28,7 +28,7 @@
TestClass.class, Greeter.class, Greeting.class, Greeting.getGreetingBase())
.addKeepMainRule(TestClass.class)
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
index a7aa579..f70aebe 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
@@ -10,7 +10,7 @@
import static org.hamcrest.core.IsNot.not;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -54,7 +54,7 @@
.addInnerClasses(InliningFromCurrentClassTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(expectedOutput)
@@ -91,7 +91,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
static {
@@ -103,7 +103,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
static {
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 ec3c011..a3b0c4a 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
@@ -51,7 +51,7 @@
neverInline
? ("-neverinline class " + getClassA().getTypeName() + " { method(); }")
: "")
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableProguardTestOptions()
.compile()
.run(TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
index c8bb388..ab412be 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
@@ -10,7 +10,7 @@
import static org.hamcrest.core.IsNot.not;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -31,7 +31,7 @@
.addInnerClasses(InliningWithClassInitializerTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
@@ -61,7 +61,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
static {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/interfacemethods/InlineDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/interfacemethods/InlineDefaultInterfaceMethodTest.java
index 0e4627b..177353f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/interfacemethods/InlineDefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/interfacemethods/InlineDefaultInterfaceMethodTest.java
@@ -7,7 +7,7 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -42,7 +42,7 @@
.addKeepMainRule(TestClass.class)
.setMinApi(parameters.getApiLevel())
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.noMinification()
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(expectedOutput)
@@ -59,7 +59,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
default void hello() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/Greeting.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/Greeting.java
index 636b0ac..717c09f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/Greeting.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/testclasses/Greeting.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.ir.optimize.inliner.testclasses;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
-@NeverMerge
+@NoVerticalClassMerging
public class Greeting extends GreetingBase {
public static Class<?> getGreetingBase() {
@@ -14,7 +14,7 @@
}
}
-@NeverMerge
+@NoVerticalClassMerging
class GreetingBase {
protected String greeting;
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 afa71fc..c8c60ae 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,7 +5,7 @@
package com.android.tools.r8.ir.optimize.inliner.testclasses;
import com.android.tools.r8.ForceInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public class InliningIntoVisibilityBridgeTestClasses {
@@ -13,7 +13,7 @@
return InliningIntoVisibilityBridgeTestClassA.class;
}
- @NeverMerge
+ @NoVerticalClassMerging
static class InliningIntoVisibilityBridgeTestClassA {
@ForceInline
@@ -22,7 +22,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class InliningIntoVisibilityBridgeTestClassB
extends InliningIntoVisibilityBridgeTestClassA {}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
index c90173e..8bdea50 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/lambda/LambdaMethodInliningTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,7 +41,7 @@
.addInnerClasses(LambdaMethodInliningTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(options -> options.enableClassInlining = false)
.setMinApi(parameters.getApiLevel())
.compile()
@@ -108,7 +108,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface ImplementedByClass {
void m();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/StaticFieldWithRefinedTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/StaticFieldWithRefinedTypeTest.java
index 7cf1f42..8473c67 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/StaticFieldWithRefinedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/StaticFieldWithRefinedTypeTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -42,7 +42,7 @@
.addInnerClasses(StaticFieldWithRefinedTypeTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(this::verifyMainIsEmpty)
@@ -75,7 +75,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {}
static class B extends A {}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
index a59e9a9..9ffd5ee 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/fields/FieldInitializedByNonConstantArgumentInSuperConstructorTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -40,7 +40,7 @@
.addInnerClasses(FieldInitializedByNonConstantArgumentInSuperConstructorTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -82,7 +82,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
int x;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullParamInterface.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullParamInterface.java
index e20992e..f4ee88c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullParamInterface.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NonNullParamInterface.java
@@ -3,9 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize.nonnull;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
-@NeverMerge
+@NoVerticalClassMerging
public interface NonNullParamInterface {
int sum(NotPinnedClass arg1, NotPinnedClass arg2);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
index 5691577..66c42e8 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b133215941/B133215941.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -63,7 +63,7 @@
testForR8(parameters.getBackend())
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableSideEffectAnnotations()
.addInnerClasses(B133215941.class)
.addKeepMainRule(TestClass.class)
@@ -84,12 +84,12 @@
.assertSuccessWithOutput(expectedOutput);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface Iface {
void ifaceMethod();
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class TestClassSuper {
@AssumeMayHaveSideEffects
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/SynchronizedCompanionMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/SynchronizedCompanionMethodTest.java
new file mode 100644
index 0000000..8df91f6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/SynchronizedCompanionMethodTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.staticizer;
+
+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.NeverInline;
+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 SynchronizedCompanionMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public SynchronizedCompanionMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+ assertThat(testClassSubject, isPresent());
+ assertEquals(
+ 1,
+ testClassSubject
+ .allMethods(method -> method.isStatic() && !method.isClassInitializer())
+ .size());
+
+ ClassSubject companionClassSubject = inspector.clazz(Companion.class);
+ assertThat(companionClassSubject, isPresent());
+ assertEquals(
+ 1,
+ companionClassSubject
+ .allMethods(method -> !method.isStatic() && method.isSynchronized())
+ .size());
+ }
+
+ static class TestClass {
+
+ static final Companion companion = new Companion();
+
+ public static void main(String[] args) {
+ companion.greet();
+ }
+ }
+
+ @NeverClassInline
+ static class Companion {
+
+ @NeverInline
+ public synchronized void greet() {
+ System.out.println("Hello world!");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InterfaceMethodTest.java
index 6ca0f7c..9fd146d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/InterfaceMethodTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.StringUtils;
@@ -47,7 +47,7 @@
.addInnerClasses(InterfaceMethodTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
@@ -76,7 +76,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
Uninstantiated m();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/NestedInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/NestedInterfaceMethodTest.java
index b5752cc..7890640 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/NestedInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/NestedInterfaceMethodTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -49,7 +49,7 @@
.addInnerClasses(NestedInterfaceMethodTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(
options -> {
options.enableDevirtualization = false;
@@ -82,13 +82,13 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
Uninstantiated m();
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends I {}
static class A implements J {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
index 7423491..167c17b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/ParameterRewritingTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.DexMethod;
@@ -53,7 +53,7 @@
.addInnerClasses(ParameterRewritingTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.addKeepRules("-dontobfuscate")
.addOptionsModification(options -> options.enableClassInlining = false)
.run(TestClass.class)
@@ -114,10 +114,10 @@
}
}
- @NeverMerge
+ @NoStaticClassMerging
static class Uninstantiated {}
- @NeverMerge
+ @NoStaticClassMerging
static class Factory {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
index a4afbb1..7d3eb83 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/VoidReturnTypeRewritingTest.java
@@ -8,7 +8,8 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.StringUtils;
@@ -50,7 +51,8 @@
.addInnerClasses(VoidReturnTypeRewritingTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.addKeepRules("-dontobfuscate")
.addOptionsModification(options -> options.enableClassInlining = false)
.run(TestClass.class)
@@ -102,13 +104,14 @@
}
}
- @NeverMerge
+ @NoStaticClassMerging
+ @NoVerticalClassMerging
static class Uninstantiated {}
- @NeverMerge
+ @NoVerticalClassMerging
static class SubUninstantiated extends Uninstantiated {}
- @NeverMerge
+ @NoVerticalClassMerging
static class Factory {
@NeverInline
@@ -124,7 +127,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class SubFactory extends Factory {
@Override
@@ -135,7 +138,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class SubSubFactory extends SubFactory {
@Override
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
index 461ec6b..7456d35 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -48,7 +48,7 @@
.addKeepMainRule(TestClass.class)
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.minification(minification)
.setMinApi(parameters.getRuntime())
.compile()
@@ -75,7 +75,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
index 08d8c09..2c7fe55 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -58,7 +58,7 @@
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.minification(minification)
.setMinApi(parameters.getRuntime())
.compile()
@@ -115,7 +115,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInMethodThatImplementsInterfaceMethodOnSubTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInMethodThatImplementsInterfaceMethodOnSubTest.java
index 9001472..9a4d4d0 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInMethodThatImplementsInterfaceMethodOnSubTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsInMethodThatImplementsInterfaceMethodOnSubTest.java
@@ -4,7 +4,7 @@
package com.android.tools.r8.ir.optimize.unusedarguments;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -32,7 +32,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(UnusedArgumentsInMethodThatImplementsInterfaceMethodOnSubTest.class)
.addKeepMainRule(TestClass.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines("Hello from A", "Hello from C");
@@ -52,7 +52,7 @@
void method(Object o);
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
public void method(Object unused) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java
index 8b2c2a1..413937e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -39,7 +39,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(UnusedInterfaceRemovalTest.class)
.addKeepMainRule(TestClass.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -77,13 +77,13 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J {
void bar();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java
index 9a342e1..52131b3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -40,7 +40,7 @@
.addInnerClasses(UnusedInterfaceWithDefaultMethodTest.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
@@ -78,13 +78,13 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
void m();
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends I {
@NeverInline
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
new file mode 100644
index 0000000..3b35a09
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
@@ -0,0 +1,84 @@
+// 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.kotlin.lambda.b159688129;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+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.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+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 LambdaGroupGCLimitTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final int LAMBDA_HOLDER_LIMIT = 50;
+ private final int LAMBDAS_PER_CLASS_LIMIT = 100;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ }
+
+ public LambdaGroupGCLimitTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws ExecutionException, CompilationFailedException, IOException {
+ String PKG_NAME = LambdaGroupGCLimitTest.class.getPackage().getName();
+ R8FullTestBuilder testBuilder =
+ testForR8(parameters.getBackend())
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .setMinApi(parameters.getApiLevel())
+ .noMinification();
+ Path classFiles = temp.newFile("classes.jar").toPath();
+ List<byte[]> classFileData = new ArrayList<>();
+ for (int mainId = 0; mainId < LAMBDA_HOLDER_LIMIT; mainId++) {
+ classFileData.add(MainKtDump.dump(mainId, LAMBDAS_PER_CLASS_LIMIT));
+ for (int lambdaId = 0; lambdaId < LAMBDAS_PER_CLASS_LIMIT; lambdaId++) {
+ classFileData.add(MainKt$main$1Dump.dump(mainId, lambdaId));
+ }
+ testBuilder.addKeepClassAndMembersRules(PKG_NAME + ".MainKt" + mainId);
+ }
+ writeClassFileDataToJar(classFiles, classFileData);
+ R8TestCompileResult compileResult = testBuilder.addProgramFiles(classFiles).compile();
+ Path path = compileResult.writeToZip();
+ compileResult
+ .run(parameters.getRuntime(), PKG_NAME + ".MainKt0")
+ .assertSuccessWithOutputLines("3")
+ .inspect(
+ codeInspector -> {
+ final List<FoundClassSubject> lambdaGroups =
+ codeInspector.allClasses().stream()
+ .filter(c -> c.getFinalName().contains("LambdaGroup"))
+ .collect(Collectors.toList());
+ assertEquals(1, lambdaGroups.size());
+ });
+ Path oatFile = temp.newFile("out.oat").toPath();
+ ProcessResult processResult =
+ ToolHelper.runDex2OatRaw(path, oatFile, parameters.getRuntime().asDex().getVm());
+ assertEquals(0, processResult.exitCode);
+ assertThat(processResult.stderr, containsString("Method exceeds compiler instruction limit"));
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Main.kt b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Main.kt
new file mode 100644
index 0000000..0bbca3c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Main.kt
@@ -0,0 +1,16 @@
+// 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.kotlin.lambda.b159688129
+
+import com.android.tools.r8.NeverInline
+
+fun main() {
+ run ({ arg -> println(arg)}, 3)
+}
+
+@NeverInline
+fun run(param: Function1<Int, Unit>, arg : Int) {
+ param.invoke(arg)
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKt$main$1Dump.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKt$main$1Dump.java
new file mode 100644
index 0000000..f9ead12
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKt$main$1Dump.java
@@ -0,0 +1,160 @@
+// 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.kotlin.lambda.b159688129;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+class MainKt$main$1Dump implements Opcodes {
+
+ public static byte[] dump(int mainId, int lambdaId) {
+
+ ClassWriter classWriter = new ClassWriter(0);
+ FieldVisitor fieldVisitor;
+ MethodVisitor methodVisitor;
+ AnnotationVisitor annotationVisitor0;
+
+ classWriter.visit(
+ V1_8,
+ ACC_FINAL | ACC_SUPER,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId,
+ "Lkotlin/jvm/internal/Lambda;Lkotlin/jvm/functions/Function1<Ljava/lang/Integer;Lkotlin/Unit;>;",
+ "kotlin/jvm/internal/Lambda",
+ new String[] {"kotlin/jvm/functions/Function1"});
+
+ classWriter.visitOuterClass(
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId,
+ lambdaId > 0 ? "main" + lambdaId : "main",
+ "()V");
+
+ {
+ annotationVisitor0 = classWriter.visitAnnotation("Lkotlin/Metadata;", true);
+ annotationVisitor0.visit("mv", new int[] {1, 1, 16});
+ annotationVisitor0.visit("bv", new int[] {1, 0, 3});
+ annotationVisitor0.visit("k", new Integer(3));
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d1");
+ annotationVisitor1.visit(
+ null,
+ "\u0000\u000e\n"
+ + "\u0000\n"
+ + "\u0002\u0010\u0002\n"
+ + "\u0000\n"
+ + "\u0002\u0010\u0008\n"
+ + "\u0000\u0010\u0000\u001a\u00020\u00012\u0006\u0010\u0002\u001a\u00020\u0003H\n"
+ + "\u00a2\u0006\u0002\u0008\u0004");
+ annotationVisitor1.visitEnd();
+ }
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d2");
+ annotationVisitor1.visit(null, "<anonymous>");
+ annotationVisitor1.visit(null, "");
+ annotationVisitor1.visit(null, "arg");
+ annotationVisitor1.visit(null, "");
+ annotationVisitor1.visit(null, "invoke");
+ annotationVisitor1.visitEnd();
+ }
+ annotationVisitor0.visitEnd();
+ }
+ classWriter.visitInnerClass(
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId,
+ null,
+ null,
+ ACC_FINAL | ACC_STATIC);
+ {
+ fieldVisitor =
+ classWriter.visitField(
+ ACC_PUBLIC | ACC_FINAL | ACC_STATIC,
+ "INSTANCE",
+ "Lcom/android/tools/r8/kotlin/lambda/b159688129/MainKt"
+ + mainId
+ + "$main$"
+ + lambdaId
+ + ";",
+ null,
+ null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PUBLIC | ACC_BRIDGE | ACC_SYNTHETIC,
+ "invoke",
+ "(Ljava/lang/Object;)Ljava/lang/Object;",
+ null,
+ null);
+ methodVisitor.visitCode();
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ALOAD, 1);
+ methodVisitor.visitTypeInsn(CHECKCAST, "java/lang/Number");
+ methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "intValue", "()I", false);
+ methodVisitor.visitMethodInsn(
+ INVOKEVIRTUAL,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId,
+ "invoke",
+ "(I)V",
+ false);
+ methodVisitor.visitFieldInsn(GETSTATIC, "kotlin/Unit", "INSTANCE", "Lkotlin/Unit;");
+ methodVisitor.visitInsn(ARETURN);
+ methodVisitor.visitMaxs(2, 2);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_FINAL, "invoke", "(I)V", null, null);
+ methodVisitor.visitCode();
+ methodVisitor.visitInsn(ICONST_0);
+ methodVisitor.visitVarInsn(ISTORE, 2);
+ methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+ methodVisitor.visitVarInsn(ILOAD, 1);
+ methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(I)V", false);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 3);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+ methodVisitor.visitCode();
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitInsn(ICONST_1);
+ methodVisitor.visitMethodInsn(
+ INVOKESPECIAL, "kotlin/jvm/internal/Lambda", "<init>", "(I)V", false);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
+ methodVisitor.visitCode();
+ methodVisitor.visitTypeInsn(
+ NEW,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId);
+ methodVisitor.visitInsn(DUP);
+ methodVisitor.visitMethodInsn(
+ INVOKESPECIAL,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId,
+ "<init>",
+ "()V",
+ false);
+ methodVisitor.visitFieldInsn(
+ PUTSTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + mainId + "$main$" + lambdaId,
+ "INSTANCE",
+ "Lcom/android/tools/r8/kotlin/lambda/b159688129/MainKt"
+ + mainId
+ + "$main$"
+ + lambdaId
+ + ";");
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 0);
+ methodVisitor.visitEnd();
+ }
+ classWriter.visitEnd();
+
+ return classWriter.toByteArray();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKtDump.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKtDump.java
new file mode 100644
index 0000000..7321fcb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/MainKtDump.java
@@ -0,0 +1,153 @@
+// 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.kotlin.lambda.b159688129;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class MainKtDump implements Opcodes {
+
+ public static byte[] dump(int id, int numberOfLambdas) {
+
+ ClassWriter classWriter = new ClassWriter(0);
+ MethodVisitor methodVisitor;
+ AnnotationVisitor annotationVisitor0;
+
+ classWriter.visit(
+ V1_8,
+ ACC_PUBLIC | ACC_FINAL | ACC_SUPER,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id,
+ null,
+ "java/lang/Object",
+ null);
+
+ {
+ annotationVisitor0 = classWriter.visitAnnotation("Lkotlin/Metadata;", true);
+ annotationVisitor0.visit("mv", new int[] {1, 1, 16});
+ annotationVisitor0.visit("bv", new int[] {1, 0, 3});
+ annotationVisitor0.visit("k", new Integer(2));
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d1");
+ annotationVisitor1.visit(
+ null,
+ "\u0000\u0016\n"
+ + "\u0000\n"
+ + "\u0002\u0010\u0002\n"
+ + "\u0002\u0008\u0002\n"
+ + "\u0002\u0018\u0002\n"
+ + "\u0002\u0010\u0008\n"
+ + "\u0002\u0008\u0002\u001a\u0006\u0010\u0000\u001a\u00020\u0001\u001a$\u0010\u0002\u001a\u00020\u00012\u0012\u0010\u0003\u001a\u000e\u0012\u0004\u0012\u00020\u0005\u0012\u0004\u0012\u00020\u00010\u00042\u0006\u0010\u0006\u001a\u00020\u0005H\u0007\u00a8\u0006\u0007");
+ annotationVisitor1.visitEnd();
+ }
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d2");
+ annotationVisitor1.visit(null, "main");
+ annotationVisitor1.visit(null, "");
+ annotationVisitor1.visit(null, "run");
+ annotationVisitor1.visit(null, "param");
+ annotationVisitor1.visit(null, "Lkotlin/Function1;");
+ annotationVisitor1.visit(null, "");
+ annotationVisitor1.visit(null, "arg");
+ annotationVisitor1.visit(null, "r8.main");
+ annotationVisitor1.visitEnd();
+ }
+ annotationVisitor0.visitEnd();
+ }
+ for (int lambdaId = 0; lambdaId < numberOfLambdas; lambdaId++) {
+ if (lambdaId > 0) {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "main" + lambdaId, "()V", null, null);
+ } else {
+ methodVisitor =
+ classWriter.visitMethod(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "main", "()V", null, null);
+ }
+ methodVisitor.visitCode();
+ methodVisitor.visitFieldInsn(
+ GETSTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id + "$main$" + lambdaId,
+ "INSTANCE",
+ "Lcom/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id + "$main$" + lambdaId + ";");
+ methodVisitor.visitTypeInsn(CHECKCAST, "kotlin/jvm/functions/Function1");
+ methodVisitor.visitInsn(ICONST_3);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id,
+ "run",
+ "(Lkotlin/jvm/functions/Function1;I)V",
+ false);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 0);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC,
+ "main",
+ "([Ljava/lang/String;)V",
+ null,
+ null);
+ methodVisitor.visitCode();
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id,
+ "main",
+ "()V",
+ false);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(0, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PUBLIC | ACC_FINAL | ACC_STATIC,
+ "run",
+ "(Lkotlin/jvm/functions/Function1;I)V",
+ "(Lkotlin/jvm/functions/Function1<-Ljava/lang/Integer;Lkotlin/Unit;>;I)V",
+ null);
+ {
+ annotationVisitor0 =
+ methodVisitor.visitAnnotation("Lcom/android/tools/r8/NeverInline;", true);
+ annotationVisitor0.visitEnd();
+ }
+ methodVisitor.visitAnnotableParameterCount(2, false);
+ {
+ annotationVisitor0 =
+ methodVisitor.visitParameterAnnotation(0, "Lorg/jetbrains/annotations/NotNull;", false);
+ annotationVisitor0.visitEnd();
+ }
+ methodVisitor.visitCode();
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitLdcInsn("param");
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC,
+ "kotlin/jvm/internal/Intrinsics",
+ "checkParameterIsNotNull",
+ "(Ljava/lang/Object;Ljava/lang/String;)V",
+ false);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 1);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
+ methodVisitor.visitMethodInsn(
+ INVOKEINTERFACE,
+ "kotlin/jvm/functions/Function1",
+ "invoke",
+ "(Ljava/lang/Object;)Ljava/lang/Object;",
+ true);
+ methodVisitor.visitInsn(POP);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 2);
+ methodVisitor.visitEnd();
+ }
+ classWriter.visitEnd();
+
+ return classWriter.toByteArray();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Test.kt b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Test.kt
new file mode 100644
index 0000000..b213076
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/Test.kt
@@ -0,0 +1,9 @@
+// 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.kotlin.lambda.b159688129
+
+fun test() {
+ run({ })
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/TestKtDump.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/TestKtDump.java
new file mode 100644
index 0000000..cf66c3e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/TestKtDump.java
@@ -0,0 +1,82 @@
+// 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.kotlin.lambda.b159688129;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class TestKtDump implements Opcodes {
+
+ public static byte[] dump(int id) {
+
+ ClassWriter classWriter = new ClassWriter(0);
+ MethodVisitor methodVisitor;
+ AnnotationVisitor annotationVisitor0;
+
+ classWriter.visit(
+ V1_8,
+ ACC_PUBLIC | ACC_FINAL | ACC_SUPER,
+ "com/android/tools/r8/kotlin/lambda/b159688129/TestKt" + id,
+ null,
+ "java/lang/Object",
+ null);
+
+ {
+ annotationVisitor0 = classWriter.visitAnnotation("Lkotlin/Metadata;", true);
+ annotationVisitor0.visit("mv", new int[] {1, 1, 16});
+ annotationVisitor0.visit("bv", new int[] {1, 0, 3});
+ annotationVisitor0.visit("k", new Integer(2));
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d1");
+ annotationVisitor1.visit(
+ null,
+ "\u0000\u0008\n"
+ + "\u0000\n"
+ + "\u0002\u0010\u0002\n"
+ + "\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001\u00a8\u0006\u0002");
+ annotationVisitor1.visitEnd();
+ }
+ {
+ AnnotationVisitor annotationVisitor1 = annotationVisitor0.visitArray("d2");
+ annotationVisitor1.visit(null, "test");
+ annotationVisitor1.visit(null, "");
+ annotationVisitor1.visit(null, "r8.main");
+ annotationVisitor1.visitEnd();
+ }
+ annotationVisitor0.visitEnd();
+ }
+ classWriter.visitInnerClass(
+ "com/android/tools/r8/kotlin/lambda/b159688129/TestKt" + id + "$test$1",
+ null,
+ null,
+ ACC_FINAL | ACC_STATIC);
+
+ {
+ methodVisitor =
+ classWriter.visitMethod(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "test", "()V", null, null);
+ methodVisitor.visitCode();
+ methodVisitor.visitFieldInsn(
+ GETSTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/TestKt" + id + "$test$1",
+ "INSTANCE",
+ "Lcom/android/tools/r8/kotlin/lambda/b159688129/TestKt" + id + "$test$1;");
+ methodVisitor.visitTypeInsn(CHECKCAST, "kotlin/jvm/functions/Function0");
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC,
+ "com/android/tools/r8/kotlin/lambda/b159688129/MainKt" + id,
+ "run",
+ "(Lkotlin/jvm/functions/Function0;)V",
+ false);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(1, 0);
+ methodVisitor.visitEnd();
+ }
+ classWriter.visitEnd();
+
+ return classWriter.toByteArray();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/IllegalFieldRebindingTest.java b/src/test/java/com/android/tools/r8/memberrebinding/IllegalFieldRebindingTest.java
index ba40c07..4095713 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/IllegalFieldRebindingTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/IllegalFieldRebindingTest.java
@@ -49,7 +49,7 @@
.addInnerClasses(IllegalFieldRebindingTest.class)
.addInnerClasses(IllegalFieldRebindingTestClasses.class)
.addKeepMainRule(TestClass.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
@@ -81,7 +81,7 @@
.addInnerClasses(IllegalFieldRebindingTest.class)
.addInnerClasses(IllegalFieldRebindingTestClasses.class)
.addKeepMainRule(OtherTestClass.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(OtherTestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java
index 77a9ea9..aa38f06 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java
@@ -43,7 +43,7 @@
MemberRebindingBridgeRemovalTest.class, MemberRebindingBridgeRemovalTestClasses.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingConflictTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingConflictTest.java
index b1ae543..9d18387 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingConflictTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingConflictTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.memberrebinding;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -48,7 +48,7 @@
.addInnerClasses(MemberRebindingConflictTestClasses.class)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -65,7 +65,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
@@ -74,7 +74,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {
// public synthetic void foo() { super.foo(); }
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/testclasses/IllegalFieldRebindingTestClasses.java b/src/test/java/com/android/tools/r8/memberrebinding/testclasses/IllegalFieldRebindingTestClasses.java
index 64b4d1f..aaba050 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/testclasses/IllegalFieldRebindingTestClasses.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/testclasses/IllegalFieldRebindingTestClasses.java
@@ -4,11 +4,11 @@
package com.android.tools.r8.memberrebinding.testclasses;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public class IllegalFieldRebindingTestClasses {
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
public static int f;
}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/testclasses/MemberRebindingBridgeRemovalTestClasses.java b/src/test/java/com/android/tools/r8/memberrebinding/testclasses/MemberRebindingBridgeRemovalTestClasses.java
index 3e15e6e..12ebac3 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/testclasses/MemberRebindingBridgeRemovalTestClasses.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/testclasses/MemberRebindingBridgeRemovalTestClasses.java
@@ -5,11 +5,11 @@
package com.android.tools.r8.memberrebinding.testclasses;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
public class MemberRebindingBridgeRemovalTestClasses {
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
index 180541a..7d0d809 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldMinificationCollisionTest.java
@@ -10,8 +10,8 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -33,7 +33,7 @@
.enableMemberValuePropagationAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput)
.inspector();
@@ -54,7 +54,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverPropagateValue public String f1;
@@ -64,7 +64,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
@NeverPropagateValue public String f2;
diff --git a/src/test/java/com/android/tools/r8/naming/InterfaceFieldMinificationTest.java b/src/test/java/com/android/tools/r8/naming/InterfaceFieldMinificationTest.java
index 4d43352..ca294fa 100644
--- a/src/test/java/com/android/tools/r8/naming/InterfaceFieldMinificationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/InterfaceFieldMinificationTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.naming.testclasses.Greeting;
import com.android.tools.r8.utils.StringUtils;
@@ -25,7 +25,7 @@
.addKeepRules("-keep,allowobfuscation class " + Tag.class.getTypeName() + " { <fields>; }")
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.run(TestClass.class)
.assertSuccessWithOutput(expectedOutput);
}
@@ -50,7 +50,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface Tag {
String TAG = "Greeter";
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 9a55cee..efb5d35 100644
--- a/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.naming;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,7 +44,7 @@
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(parameters.getBackend())
.addInnerClasses(IntersectionLambdaTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
@@ -52,7 +52,7 @@
}
@FunctionalInterface
- @NeverMerge
+ @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 5b26d4f..93a0639 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -15,6 +15,9 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.kotlin.TestKotlinClass;
+import com.android.tools.r8.shaking.NoHorizontalClassMergingRule;
+import com.android.tools.r8.shaking.NoStaticClassMergingRule;
+import com.android.tools.r8.shaking.NoVerticalClassMergingRule;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -130,7 +133,9 @@
.addKeepRules(
StringUtils.lines(
"-neverclassinline class **." + targetClassName,
- "-nevermerge class **." + targetClassName,
+ "-" + NoVerticalClassMergingRule.RULE_NAME + " class **." + targetClassName,
+ "-" + NoHorizontalClassMergingRule.RULE_NAME + " class **." + targetClassName,
+ "-" + NoStaticClassMergingRule.RULE_NAME + " class **." + targetClassName,
"-neverinline class **." + targetClassName + " { <methods>; }"))
.allowDiagnosticWarningMessages()
.minification(minification)
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
index e93b0fa..c4b3181 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInInterfacesWithCommonSubClassTest.java
@@ -10,7 +10,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -45,7 +45,7 @@
CodeInspector inspector =
testForR8(Backend.DEX)
.addProgramClasses(TestClass.class, A.class, B.class, I.class, J.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(TestClass.class)
.addKeepRules(
reserveName
@@ -85,22 +85,22 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
String f1 = System.currentTimeMillis() >= 0 ? "Hello " : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J {
String a = System.currentTimeMillis() >= 0 ? "world!" : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A implements I {}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A implements J {
@Override
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
index 67b86ce..38bcbad 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubClassTest.java
@@ -9,8 +9,8 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
@@ -52,7 +52,7 @@
.addProgramClasses(
TestClass.class, A.class, B.class, C.class, I.class, J.class, K.class)
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(TestClass.class)
.addKeepRules(
reserveName
@@ -140,31 +140,31 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverPropagateValue String f1 = "He";
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
@NeverPropagateValue String f2 = "l";
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
String f3 = System.currentTimeMillis() >= 0 ? "lo" : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends I {
String f4 = System.currentTimeMillis() >= 0 ? " " : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
interface K {
String f5 = System.currentTimeMillis() >= 0 ? "world" : null;
diff --git a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
index 89804e8..65c62b8 100644
--- a/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/ReservedFieldNameInSubInterfaceTest.java
@@ -10,8 +10,8 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeFalse;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.BooleanUtils;
@@ -48,7 +48,7 @@
testForR8(Backend.DEX)
.addProgramClasses(TestClass.class, A.class, B.class, I.class, J.class)
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(TestClass.class)
.addKeepRules(
reserveName
@@ -105,7 +105,7 @@
.addLibraryClasses(I.class, J.class)
.addLibraryFiles(runtimeJar(Backend.DEX))
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(TestClass.class)
.compile()
.addRunClasspathFiles(
@@ -126,19 +126,19 @@
assertEquals(expectedNameForF2, f2FieldSubject.getFinalName());
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
String f1 = System.currentTimeMillis() >= 0 ? "Hello" : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends I {
String a = System.currentTimeMillis() >= 0 ? "world!" : null;
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverPropagateValue String f2 = " ";
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 7fa0543..4d000bb 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
@@ -10,8 +10,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -81,7 +81,7 @@
}
private static final Class<?>[] LIBRARY_CLASSES = {
- NeverMerge.class, LibraryBase.class, LibrarySubclass.class
+ NoVerticalClassMerging.class, LibraryBase.class, LibrarySubclass.class
};
private static final Class<?>[] PROGRAM_CLASSES = {
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/MemberResolutionTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/MemberResolutionTest.java
index 725c5a9..cbd6e3b 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/MemberResolutionTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/MemberResolutionTest.java
@@ -8,8 +8,8 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -27,7 +27,7 @@
import org.junit.runners.Parameterized;
// AbstractChecker -> X:
-@NeverMerge
+@NoVerticalClassMerging
abstract class AbstractChecker {
// String tag -> p
@NeverPropagateValue private String tag = "PrivateInitialTag_AbstractChecker";
@@ -123,7 +123,7 @@
.addKeepMainRule(MemberResolutionTestMain.class)
.addKeepRules("-applymapping " + mapPath)
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addOptionsModification(options -> options.enableInlining = false)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MemberResolutionTestMain.class)
diff --git a/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java b/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
index 5da3af5..66b2a18 100644
--- a/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.CompatProguardCommandBuilder;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
@@ -24,10 +24,10 @@
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
-@NeverMerge
+@NoStaticClassMerging
class Outer {
- @NeverMerge
+ @NoStaticClassMerging
static class Inner {
@NeverInline
static void foo() {
@@ -80,7 +80,7 @@
// the visiting of classes during class minification to be Outer$Inner before Outer.
"-keepnames class " + Outer.class.getCanonicalName() + "$Inner",
keepOuterName ? "-keepnames class " + Outer.class.getCanonicalName() : "",
- "-nevermerge @com.android.tools.r8.NeverMerge class *"),
+ noStaticClassMergingRule()),
Origin.unknown());
ToolHelper.allowTestProguardOptions(builder);
diff --git a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
index 56ed80c..0add817 100644
--- a/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
+++ b/src/test/java/com/android/tools/r8/naming/b128656974/B128656974.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.naming.testclasses.Greeting;
import com.android.tools.r8.utils.StringUtils;
@@ -27,7 +27,7 @@
testForR8(Backend.DEX)
.addProgramClasses(Greeting.class, Greeting.getGreetingBase(), TestClassSub.class, main)
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(main)
.addKeepRules(
"-keepclassmembernames class "
@@ -74,7 +74,7 @@
Class<?> main = TestClassMainForMethod.class;
testForR8(Backend.DEX)
.addProgramClasses(TestClassBase.class, TestClassSub2.class, main)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(main)
@@ -92,7 +92,7 @@
});
}
- @NeverMerge
+ @NoVerticalClassMerging
static class TestClassBase {
@NeverInline
void foo() {
diff --git a/src/test/java/com/android/tools/r8/naming/testclasses/Greeting.java b/src/test/java/com/android/tools/r8/naming/testclasses/Greeting.java
index 221301b..20f6df1 100644
--- a/src/test/java/com/android/tools/r8/naming/testclasses/Greeting.java
+++ b/src/test/java/com/android/tools/r8/naming/testclasses/Greeting.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.naming.testclasses;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
-@NeverMerge
+@NoVerticalClassMerging
public class Greeting extends GreetingBase {
public static Class<?> getGreetingBase() {
@@ -14,7 +14,7 @@
}
}
-@NeverMerge
+@NoVerticalClassMerging
class GreetingBase {
protected String greeting;
diff --git a/src/test/java/com/android/tools/r8/repackage/CrossPackageInvokeSuperToPackagePrivateMethodTest.java b/src/test/java/com/android/tools/r8/repackage/CrossPackageInvokeSuperToPackagePrivateMethodTest.java
index 32a8cc8..4e4001a 100644
--- a/src/test/java/com/android/tools/r8/repackage/CrossPackageInvokeSuperToPackagePrivateMethodTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/CrossPackageInvokeSuperToPackagePrivateMethodTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestBuilder;
@@ -53,7 +53,7 @@
.apply(this::addProgramClasses)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -112,7 +112,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
public static class A {
@NeverInline
@@ -122,7 +122,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageAfterCollisionWithPackagePrivateSignatureTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageAfterCollisionWithPackagePrivateSignatureTest.java
index 1639c79..8e08452 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageAfterCollisionWithPackagePrivateSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageAfterCollisionWithPackagePrivateSignatureTest.java
@@ -4,10 +4,11 @@
package com.android.tools.r8.repackage;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.FLATTEN_PACKAGE_HIERARCHY;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.REPACKAGE_CLASSES;
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.NeverInline;
import com.android.tools.r8.TestBase;
@@ -25,8 +26,6 @@
@RunWith(Parameterized.class)
public class RepackageAfterCollisionWithPackagePrivateSignatureTest extends TestBase {
- private static final String FLATTEN_PACKAGE_HIERARCHY = "flattenpackagehierarchy";
- private static final String REPACKAGE_CLASSES = "repackageclasses";
private static final String REPACKAGE_DIR = "foo";
private final String flattenPackageHierarchyOrRepackageClasses;
@@ -76,7 +75,7 @@
public static void main(String[] args) {
RepackageCandidate.foo(0);
- RepackageCandidate.foo((int) System.currentTimeMillis(), 0);
+ RepackageCandidate.foo(System.currentTimeMillis(), 0);
}
static void restrictToCurrentPackage() {
@@ -86,12 +85,12 @@
public static class RepackageCandidate {
- public static void foo(int unused) {
+ public static void foo(long unused) {
TestClass.restrictToCurrentPackage();
}
@NeverInline
- public static void foo(int used, int unused) {
+ public static void foo(long used, int unused) {
if (used >= 0) {
System.out.println(" world!");
}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageTest.java
index c656981..1d9718b 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageTest.java
@@ -129,7 +129,7 @@
options ->
options.testing.enableExperimentalRepackaging = enableExperimentalRepackaging)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoStaticClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithFeatureSplitTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithFeatureSplitTest.java
new file mode 100644
index 0000000..40e7721
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithFeatureSplitTest.java
@@ -0,0 +1,111 @@
+// 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.repackage;
+
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.FLATTEN_PACKAGE_HIERARCHY;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.REPACKAGE_CLASSES;
+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.assertFalse;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.dexsplitter.SplitterTestBase.RunInterface;
+import com.android.tools.r8.dexsplitter.SplitterTestBase.SplitRunner;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+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 RepackageWithFeatureSplitTest extends TestBase {
+
+ private static final String REPACKAGE_DIR = "foo";
+
+ private final String flattenPackageHierarchyOrRepackageClasses;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, kind: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of(FLATTEN_PACKAGE_HIERARCHY, REPACKAGE_CLASSES),
+ getTestParameters().withDexRuntimes().withAllApiLevels().build());
+ }
+
+ public RepackageWithFeatureSplitTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ this.flattenPackageHierarchyOrRepackageClasses = flattenPackageHierarchyOrRepackageClasses;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(BaseClass.class)
+ .addFeatureSplit(FeatureMain.class, FeatureClass.class)
+ .addFeatureSplitRuntime()
+ .addKeepFeatureMainRule(FeatureMain.class)
+ .addKeepRules(
+ "-" + flattenPackageHierarchyOrRepackageClasses + " \"" + REPACKAGE_DIR + "\"")
+ .addOptionsModification(
+ options -> {
+ assertFalse(options.testing.enableExperimentalRepackaging);
+ options.testing.enableExperimentalRepackaging = true;
+ })
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspectBase, this::inspectFeature)
+ .runFeature(parameters.getRuntime(), FeatureMain.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspectBase(CodeInspector inspector) {
+ assertEquals(3, inspector.allClasses().size());
+
+ // The base classes added here.
+ assertThat(inspector.clazz(BaseClass.class), isPresent());
+
+ // The feature split runtime.
+ assertThat(inspector.clazz(RunInterface.class), isPresent());
+ assertThat(inspector.clazz(SplitRunner.class), isPresent());
+ }
+
+ private void inspectFeature(CodeInspector inspector) {
+ assertEquals(2, inspector.allClasses().size());
+ assertThat(inspector.clazz(FeatureMain.class), isPresent());
+ assertThat(inspector.clazz(FeatureClass.class), isPresent());
+ }
+
+ public static class BaseClass {
+
+ @NeverInline
+ public static void hello() {
+ System.out.print("Hello");
+ }
+ }
+
+ public static class FeatureMain implements RunInterface {
+
+ @Override
+ public void run() {
+ BaseClass.hello();
+ FeatureClass.world();
+ }
+ }
+
+ public static class FeatureClass {
+
+ @NeverInline
+ public static void world() {
+ System.out.println(" world!");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
new file mode 100644
index 0000000..501340a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithInitClassTest.java
@@ -0,0 +1,98 @@
+// 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.repackage;
+
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.FLATTEN_PACKAGE_HIERARCHY;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.REPACKAGE_CLASSES;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+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.CodeInspector;
+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 RepackageWithInitClassTest extends TestBase {
+
+ private static final String REPACKAGE_PACKAGE = "foo";
+
+ private final String flattenPackageHierarchyOrRepackageClasses;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, kind: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of(FLATTEN_PACKAGE_HIERARCHY, REPACKAGE_CLASSES),
+ getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ public RepackageWithInitClassTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ this.flattenPackageHierarchyOrRepackageClasses = flattenPackageHierarchyOrRepackageClasses;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addClassObfuscationDictionary("a")
+ .addKeepMainRule(TestClass.class)
+ .addKeepRules(
+ "-" + flattenPackageHierarchyOrRepackageClasses + " \"" + REPACKAGE_PACKAGE + "\"")
+ .addOptionsModification(
+ options -> {
+ assert !options.testing.enableExperimentalRepackaging;
+ options.testing.enableExperimentalRepackaging = true;
+ })
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject repackagedClassSubject = inspector.clazz(StaticMemberValuePropagation.class);
+ assertThat(repackagedClassSubject, isPresent());
+
+ // Verify that a $r8$clinit field was synthesized.
+ String clinitFieldName = inspector.getFactory().objectMembers.clinitField.name.toSourceString();
+ assertThat(repackagedClassSubject.uniqueFieldWithName(clinitFieldName), isPresent());
+ assertThat(repackagedClassSubject.uniqueFieldWithName("GREETING"), not(isPresent()));
+
+ // Verify that the class was repackaged.
+ assertEquals(
+ flattenPackageHierarchyOrRepackageClasses.equals(FLATTEN_PACKAGE_HIERARCHY)
+ ? REPACKAGE_PACKAGE + ".a"
+ : REPACKAGE_PACKAGE,
+ repackagedClassSubject.getDexProgramClass().getType().getPackageName());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.println(StaticMemberValuePropagation.GREETING);
+ }
+ }
+
+ public static class StaticMemberValuePropagation {
+
+ public static String GREETING = " world!";
+
+ static {
+ System.out.print("Hello");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundFieldReferenceTest.java b/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundFieldReferenceTest.java
new file mode 100644
index 0000000..c8a9d82
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundFieldReferenceTest.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.repackage;
+
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.FLATTEN_PACKAGE_HIERARCHY;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.REPACKAGE_CLASSES;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.repackage.RepackageWithMainDexListTest.TestClass;
+import com.android.tools.r8.repackage.testclasses.RepackagingWithNonReboundFieldReferenceTestClasses;
+import com.android.tools.r8.repackage.testclasses.RepackagingWithNonReboundFieldReferenceTestClasses.B;
+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 RepackagingWithNonReboundFieldReferenceTest extends TestBase {
+
+ private static final String REPACKAGE_DIR = "foo";
+
+ private final String flattenPackageHierarchyOrRepackageClasses;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, kind: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of(FLATTEN_PACKAGE_HIERARCHY, REPACKAGE_CLASSES),
+ getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ public RepackagingWithNonReboundFieldReferenceTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ this.flattenPackageHierarchyOrRepackageClasses = flattenPackageHierarchyOrRepackageClasses;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ try {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass(), RepackagingWithNonReboundFieldReferenceTestClasses.class)
+ .addKeepMainRule(TestClass.class)
+ .addKeepRules(
+ "-" + flattenPackageHierarchyOrRepackageClasses + " \"" + REPACKAGE_DIR + "\"")
+ .addOptionsModification(
+ options -> {
+ assertFalse(options.testing.enableExperimentalRepackaging);
+ options.testing.enableExperimentalRepackaging = true;
+ })
+ .enableMemberValuePropagationAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ // TODO(b/168282032): Support lens rewriting of non-rebound references in the writer.
+ fail();
+ } catch (CompilationFailedException exception) {
+ // Ignore.
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.println(B.GREETING);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundMethodReferenceTest.java b/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundMethodReferenceTest.java
new file mode 100644
index 0000000..48891e7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackagingWithNonReboundMethodReferenceTest.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.repackage;
+
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.FLATTEN_PACKAGE_HIERARCHY;
+import static com.android.tools.r8.shaking.ProguardConfigurationParser.REPACKAGE_CLASSES;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.repackage.testclasses.RepackagingWithNonReboundMethodReferenceTestClasses;
+import com.android.tools.r8.repackage.testclasses.RepackagingWithNonReboundMethodReferenceTestClasses.B;
+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 RepackagingWithNonReboundMethodReferenceTest extends TestBase {
+
+ private static final String REPACKAGE_DIR = "foo";
+
+ private final String flattenPackageHierarchyOrRepackageClasses;
+ private final TestParameters parameters;
+
+ @Parameters(name = "{1}, kind: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of(FLATTEN_PACKAGE_HIERARCHY, REPACKAGE_CLASSES),
+ getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ public RepackagingWithNonReboundMethodReferenceTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ this.flattenPackageHierarchyOrRepackageClasses = flattenPackageHierarchyOrRepackageClasses;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ try {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass(), RepackagingWithNonReboundMethodReferenceTestClasses.class)
+ .addKeepMainRule(TestClass.class)
+ .addKeepRules(
+ "-" + flattenPackageHierarchyOrRepackageClasses + " \"" + REPACKAGE_DIR + "\"")
+ .addOptionsModification(
+ options -> {
+ assertFalse(options.testing.enableExperimentalRepackaging);
+ options.testing.enableExperimentalRepackaging = true;
+ })
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ // TODO(b/168282032): Support lens rewriting of non-rebound references in the writer.
+ fail();
+ } catch (CompilationFailedException exception) {
+ // Ignore.
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new B().greet();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/CrossPackageInvokeSuperToPackagePrivateMethodTestClasses.java b/src/test/java/com/android/tools/r8/repackage/testclasses/CrossPackageInvokeSuperToPackagePrivateMethodTestClasses.java
index fc9639a..c9c8690 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/CrossPackageInvokeSuperToPackagePrivateMethodTestClasses.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/CrossPackageInvokeSuperToPackagePrivateMethodTestClasses.java
@@ -6,13 +6,13 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.repackage.CrossPackageInvokeSuperToPackagePrivateMethodTest;
public class CrossPackageInvokeSuperToPackagePrivateMethodTestClasses {
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
public static class C extends CrossPackageInvokeSuperToPackagePrivateMethodTest.B {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundFieldReferenceTestClasses.java b/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundFieldReferenceTestClasses.java
new file mode 100644
index 0000000..b33496f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundFieldReferenceTestClasses.java
@@ -0,0 +1,19 @@
+// 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.repackage.testclasses;
+
+import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
+
+public class RepackagingWithNonReboundFieldReferenceTestClasses {
+
+ @NoVerticalClassMerging
+ static class A {
+
+ @NeverPropagateValue public static String GREETING = "Hello world!";
+ }
+
+ public static class B extends A {}
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundMethodReferenceTestClasses.java b/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundMethodReferenceTestClasses.java
new file mode 100644
index 0000000..fb4775f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/RepackagingWithNonReboundMethodReferenceTestClasses.java
@@ -0,0 +1,24 @@
+// 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.repackage.testclasses;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+
+public class RepackagingWithNonReboundMethodReferenceTestClasses {
+
+ @NeverClassInline
+ @NoVerticalClassMerging
+ static class A {
+
+ @NeverInline
+ public void greet() {
+ System.out.println("Hello world!");
+ }
+ }
+
+ public static class B extends A {}
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassDirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassDirect.java
index 8089eb2..4f47751 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassDirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassDirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassDirect {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassIndirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassIndirect.java
index c7c3695..fdc4a9c 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassIndirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassIndirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateKeptMethodAllowRenamingOnReachableClassIndirect {
@NeverInline
@@ -15,7 +15,7 @@
Helper.test();
}
- @NeverMerge
+ @NoStaticClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassDirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassDirect.java
index 6948b55..0f9ae96 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassDirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassDirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateKeptMethodOnReachableClassDirect {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassIndirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassIndirect.java
index 7d5baae..68aa391 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassIndirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateKeptMethodOnReachableClassIndirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateKeptMethodOnReachableClassIndirect {
@NeverInline
@@ -15,7 +15,7 @@
Helper.test();
}
- @NeverMerge
+ @NoStaticClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingDirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingDirect.java
index f3a90e6..de0e859 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingDirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingDirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnKeptClassAllowRenamingDirect {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingIndirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingIndirect.java
index ddfd95b..13fef6e 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingIndirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassAllowRenamingIndirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnKeptClassAllowRenamingIndirect {
@NeverInline
@@ -15,7 +15,7 @@
Helper.test();
}
- @NeverMerge
+ @NoStaticClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassDirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassDirect.java
index 11110bd..fc92f85 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassDirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnKeptClassDirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnKeptClassDirect {
@NeverInline
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 0b737ff..c30cd59 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
@@ -5,9 +5,10 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
+import com.android.tools.r8.NoVerticalClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnKeptClassIndirect {
@NeverInline
@@ -15,7 +16,7 @@
Helper.test();
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassDirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassDirect.java
index f9a5b76..73f2d6e 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassDirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassDirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnReachableClassDirect {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassIndirect.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassIndirect.java
index 2c0a1b2..54cbea9 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassIndirect.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPackagePrivateMethodOnReachableClassIndirect.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPackagePrivateMethodOnReachableClassIndirect {
@NeverInline
@@ -15,7 +15,7 @@
Helper.test();
}
- @NeverMerge
+ @NoStaticClassMerging
public static class Helper {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodAllowRenamingOnReachableClass.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodAllowRenamingOnReachableClass.java
index 0f54397..cfb5aa4 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodAllowRenamingOnReachableClass.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodAllowRenamingOnReachableClass.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPublicKeptMethodAllowRenamingOnReachableClass {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodOnReachableClass.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodOnReachableClass.java
index dcd6aa4..75d353c 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodOnReachableClass.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicKeptMethodOnReachableClass.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPublicKeptMethodOnReachableClass {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClass.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClass.java
index f6cf98a..b77f419 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClass.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClass.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPublicMethodOnKeptClass {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClassAllowRenaming.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClassAllowRenaming.java
index 05f943c..f71b585 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClassAllowRenaming.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnKeptClassAllowRenaming.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPublicMethodOnKeptClassAllowRenaming {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnReachableClass.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnReachableClass.java
index 0c21cef..87ed71f 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnReachableClass.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/AccessPublicMethodOnReachableClass.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class AccessPublicMethodOnReachableClass {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/ReachableClass.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/ReachableClass.java
index 57b2d65..10f12bf 100644
--- a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/ReachableClass.java
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagetest/ReachableClass.java
@@ -5,9 +5,9 @@
package com.android.tools.r8.repackage.testclasses.repackagetest;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class ReachableClass {
@NeverInline
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 440e077..3215f17 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -85,7 +85,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(DefaultMethodAsOverrideWithLambdaTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -94,7 +94,7 @@
}
@FunctionalInterface
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
@@ -103,7 +103,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J extends I {
@Override
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 edbb580..77fa9d8 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -81,7 +81,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(DefaultMethodLambdaTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -90,7 +90,7 @@
}
@FunctionalInterface
- @NeverMerge
+ @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 8d2a599..70a350f 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -144,12 +144,12 @@
return transformer(A.class).setImplements(I.class, K.class).transform();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J {
@NeverInline
default void foo() {
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
index ef5656d..8b1f615 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -82,7 +82,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(DuplicateImportsTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -90,12 +90,12 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J extends I {
@Override
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 0702c97..5422f9b 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -82,7 +82,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(LambdaMultipleInterfacesTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -91,7 +91,7 @@
}
@FunctionalInterface
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
index 5ad3690..eb88c69 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -82,7 +82,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(MultipleImplementsTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -90,17 +90,17 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class A implements I, J {}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
index 4d195e1..ec16d6d 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -89,7 +89,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(SimpleInterfaceInvokeTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -97,7 +97,7 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
index 51727c7..3e582c5 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -88,7 +88,7 @@
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(parameters.getBackend())
.addInnerClasses(SubInterfaceOverridesTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -97,13 +97,13 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J extends I {
@Override
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
index 9c02be6..5628ea2 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -87,7 +87,7 @@
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(parameters.getBackend())
.addInnerClasses(SubTypeMissingOverridesTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -96,7 +96,7 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
index d5d1ce8..65d8bca 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -87,7 +87,7 @@
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(parameters.getBackend())
.addInnerClasses(SubTypeOverridesTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -96,7 +96,7 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
index 7f52044..787f992 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -83,7 +83,7 @@
public void testR8() throws IOException, CompilationFailedException, ExecutionException {
testForR8(parameters.getBackend())
.addInnerClasses(AbstractInMiddleTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
@@ -92,7 +92,7 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public static class A {
@@ -102,14 +102,14 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class B extends A {
@Override
public abstract void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
public static class C extends B {
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
index 6264f35..80b6908 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -83,18 +83,18 @@
.addKeepMainRule(Main.class)
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J extends I {
@Override
@NeverInline
@@ -103,7 +103,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class A implements I {}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
index 8f818b2..a4966b4 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -83,18 +83,18 @@
.addKeepMainRule(Main.class)
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J extends I {
@Override
@NeverInline
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 2b236b5..0daaa44 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
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -95,12 +95,12 @@
return transformer(A.class).setImplements(I.class, J.class).transform();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
void foo();
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface J {
@NeverInline
default void foo() {
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
index 9c7245c..dcb03f9 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -82,13 +82,13 @@
.addKeepMainRule(Main.class)
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
index fbf8ac5..c1f2301 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -89,7 +89,7 @@
testForR8(parameters.getBackend())
.addInnerClasses(TargetInDefaultMethodTest.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
@@ -97,7 +97,7 @@
.assertSuccessWithOutputLines(EXPECTED);
}
- @NeverMerge
+ @NoVerticalClassMerging
public interface I {
@NeverInline
default void foo() {
@@ -105,7 +105,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class A implements I {}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/shaking/B149831282.java b/src/test/java/com/android/tools/r8/shaking/B149831282.java
index 97441cc..67b9bca 100644
--- a/src/test/java/com/android/tools/r8/shaking/B149831282.java
+++ b/src/test/java/com/android/tools/r8/shaking/B149831282.java
@@ -8,7 +8,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestBuilder;
import com.android.tools.r8.TestParameters;
@@ -46,7 +46,7 @@
.apply(this::addProgramInputs)
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -84,7 +84,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@NeverInline
@@ -93,7 +93,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalInstanceFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalInstanceFieldsTest.java
index 66c8152..745e5b7 100644
--- a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalInstanceFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalInstanceFieldsTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,7 +53,7 @@
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(
@@ -154,7 +154,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class InstanceFieldWithInitialization_Z {
boolean alwaysFalse;
InstanceFieldWithInitialization_Z() {
diff --git a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
index 302cb28..35cd9c9 100644
--- a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
@@ -11,7 +11,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,7 +53,7 @@
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(
@@ -147,7 +147,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class StaticFieldWithInitialization_Z {
static boolean alwaysFalse;
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
index 741496d..382f515 100644
--- a/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EventuallyNonTargetedMethodTest.java
@@ -8,7 +8,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -39,7 +39,7 @@
public void test() throws Exception {
testForR8(parameters.getBackend())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addInnerClasses(EventuallyNonTargetedMethodTest.class)
.addKeepMainRule(Main.class)
@@ -56,7 +56,7 @@
assertThat(classSubject.uniqueMethodWithName("foo"), isPresent());
}
- @NeverMerge
+ @NoVerticalClassMerging
private static class A {
@NeverInline
public void foo() {
@@ -64,7 +64,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
private static class B extends A {
// No override of foo, but B::foo will be the only target.
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInInterfaceMarkingTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInInterfaceMarkingTest.java
index bff8192..437cdd2 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInInterfaceMarkingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInInterfaceMarkingTest.java
@@ -6,7 +6,7 @@
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -40,7 +40,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(
options -> options.testing.enqueuerInspector = this::verifyLibraryOverrideInformation)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines("true", "true");
@@ -79,7 +79,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
abstract static class A extends AbstractList<Object> {
@Override
@@ -98,13 +98,13 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
boolean isEmpty();
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A implements I {
// Intentionally empty.
}
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 9d16769..7d68070 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideInLambdaMarkingTest.java
@@ -6,7 +6,7 @@
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,7 +43,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(
options -> options.testing.enqueuerInspector = this::verifyLibraryOverrideInformation)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutputLines("null", "null");
@@ -88,14 +88,14 @@
}
@FunctionalInterface
- @NeverMerge
+ @NoVerticalClassMerging
interface I {
Iterator<Object> iterator();
}
@FunctionalInterface
- @NeverMerge
+ @NoVerticalClassMerging
interface J extends Iterable<Object> {
@Override
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideMarkingTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideMarkingTest.java
index df8fdc4..a7908c2 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideMarkingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryMethodOverrideMarkingTest.java
@@ -8,7 +8,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,7 +41,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(
options -> options.testing.enqueuerInspector = this::verifyLibraryOverrideInformation)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile();
}
@@ -69,7 +69,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
@Override
@@ -78,7 +78,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class B extends A {
@Override
diff --git a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
index 8f560a2..f813bf2 100644
--- a/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/NonTargetedMethodTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -40,7 +40,7 @@
public void test() throws Exception {
testForR8(parameters.getBackend())
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addInnerClasses(NonTargetedMethodTest.class)
.addKeepMainRule(Main.class)
@@ -56,7 +56,7 @@
assertThat(classSubject.uniqueMethodWithName("foo"), not(isPresent()));
}
- @NeverMerge
+ @NoVerticalClassMerging
private static class A {
@NeverInline
public void foo() {
@@ -64,7 +64,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
@NeverClassInline
private static class B extends A {
// No override of foo, but B::foo will be the only target.
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnTargetedMethodTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnTargetedMethodTest.java
index f4917c7..c4d9068 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnTargetedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationsOnTargetedMethodTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.shaking.annotations;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -54,7 +54,7 @@
.addKeepMainRule(TestClass.class)
.addKeepRules("-keepattributes *Annotation*", "-dontobfuscate")
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(expectedOutput);
@@ -83,7 +83,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Interface {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
index 9c38214..8462593 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -43,7 +43,7 @@
public void testR8() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(AssumenosideeffectsPropagationWithoutMatchingDefinitionTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules(
@@ -76,7 +76,7 @@
void debug(String tag, String message);
}
- @NeverMerge
+ @NoVerticalClassMerging
static class BaseImplementer implements LoggerInterface {
@Override
public void debug(String message) {
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsVisibleMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsVisibleMethodsTest.java
index 71614d2..6b053ee 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsVisibleMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsVisibleMethodsTest.java
@@ -6,7 +6,7 @@
import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
@@ -157,7 +157,7 @@
.addKeepMainRule(MAIN)
.addKeepRules(config.getKeepRule())
.noMinification()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -178,7 +178,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
static class ProgramBase extends LibraryBase {
@NeverInline
@Override
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
index 34b1b33..daaacb2 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsWithMultipleTargetsTest.java
@@ -10,7 +10,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.errors.Unreachable;
@@ -93,7 +93,7 @@
public void testR8() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(AssumenosideeffectsWithMultipleTargetsTest.class)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(MAIN)
@@ -109,9 +109,8 @@
void info(String tag, String message);
}
- @NeverMerge
- static abstract class AbstractLogger implements TestLogger {
- }
+ @NoVerticalClassMerging
+ abstract static class AbstractLogger implements TestLogger {}
@NeverClassInline
static class TestLoggerImplementer implements TestLogger {
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
index 27bb092..c2be7a8 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
@@ -5,7 +5,7 @@
import static org.hamcrest.CoreMatchers.containsString;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
@@ -17,7 +17,7 @@
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
-@NeverMerge
+@NoVerticalClassMerging
interface I {
static void foo() {
System.out.println("static::foo");
@@ -61,7 +61,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(I.class, C.class, MAIN)
.setMinApi(parameters.getApiLevel())
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { <methods>; }")
.compile()
@@ -75,7 +75,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(I.class, C.class, MAIN)
.setMinApi(parameters.getApiLevel())
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { *(); }")
.compile()
@@ -89,7 +89,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(I.class, C.class, MAIN)
.setMinApi(parameters.getApiLevel())
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { *** f*(); }")
.compile()
@@ -103,7 +103,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(I.class, C.class, MAIN)
.setMinApi(parameters.getApiLevel())
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { static void foo(); }")
.allowDiagnosticWarningMessages()
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
index 8c782f2..14c99ba 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/dflt/DefaultMethodsTest.java
@@ -10,7 +10,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.shaking.methods.MethodsTestBase.Shrinker;
import com.android.tools.r8.utils.AndroidApiLevel;
@@ -26,32 +26,32 @@
import java.util.function.Function;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
interface SuperIface {
default void m1() {}
}
-@NeverMerge
+@NoVerticalClassMerging
interface SubIface extends SuperIface {
default void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
interface SubSubIface extends SubIface {
default void m3() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class Impl implements SubSubIface {
void m4() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubImpl extends Impl {
void m5() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSubImpl extends SubImpl {
void m6() {}
}
@@ -111,7 +111,7 @@
throws Throwable {
testForR8(Backend.DEX)
.setMinApi(AndroidApiLevel.L)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addProgramClasses(getClasses())
.addKeepRules(keepRules)
.compile()
@@ -125,7 +125,7 @@
throws Throwable {
testForR8Compat(Backend.DEX)
.setMinApi(AndroidApiLevel.L)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addProgramClasses(getClasses())
.addKeepRules(keepRules)
.compile()
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
index 5f6a618..a48c5e9 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/interfacemethods/BridgeInliningTest.java
@@ -7,7 +7,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
@@ -17,7 +17,7 @@
import java.lang.reflect.Method;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
interface I {
default void m() {
System.out.println("I::m");
@@ -45,7 +45,7 @@
testForR8(Backend.DEX)
.addProgramClasses(I.class, C.class, MAIN)
.setMinApi(AndroidApiLevel.L)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { m(); }")
.run(MAIN)
diff --git a/src/test/java/com/android/tools/r8/shaking/fields/FieldsTestBase.java b/src/test/java/com/android/tools/r8/shaking/fields/FieldsTestBase.java
index 061e91a..c461169 100644
--- a/src/test/java/com/android/tools/r8/shaking/fields/FieldsTestBase.java
+++ b/src/test/java/com/android/tools/r8/shaking/fields/FieldsTestBase.java
@@ -4,7 +4,7 @@
package com.android.tools.r8.shaking.fields;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.ThrowingConsumer;
@@ -25,7 +25,7 @@
String expected)
throws Throwable {
testForR8(Backend.DEX)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addProgramClasses(getClasses())
.addKeepRules(keepRules)
.compile()
@@ -41,7 +41,7 @@
throws Throwable {
testForProguard()
.addProgramClasses(getClasses())
- .addProgramClasses(NeverMerge.class)
+ .addProgramClasses(NoVerticalClassMerging.class)
.addKeepRules(keepRules)
.compile()
.inspect(inspector)
diff --git a/src/test/java/com/android/tools/r8/shaking/fields/pblc/PublicFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/fields/pblc/PublicFieldsTest.java
index 7ac89e0..f2f68d8 100644
--- a/src/test/java/com/android/tools/r8/shaking/fields/pblc/PublicFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/fields/pblc/PublicFieldsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.fields.FieldsTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -17,17 +17,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
public int f1;
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
public int f2;
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
public int f3;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/fields/pckg/PackageFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/fields/pckg/PackageFieldsTest.java
index 86c22f6..113b862 100644
--- a/src/test/java/com/android/tools/r8/shaking/fields/pckg/PackageFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/fields/pckg/PackageFieldsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.fields.FieldsTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -17,17 +17,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
int f1;
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
int f2;
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
int f3;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/fields/prvt/PrivateFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/fields/prvt/PrivateFieldsTest.java
index 0ceefb4..e70f0a3 100644
--- a/src/test/java/com/android/tools/r8/shaking/fields/prvt/PrivateFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/fields/prvt/PrivateFieldsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.fields.FieldsTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -17,17 +17,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
private int f1;
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
private int f2;
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
private int f3;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/fields/shadow/ShadowFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/fields/shadow/ShadowFieldsTest.java
index 6cc26a6..da756b3 100644
--- a/src/test/java/com/android/tools/r8/shaking/fields/shadow/ShadowFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/fields/shadow/ShadowFieldsTest.java
@@ -7,7 +7,7 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.fields.FieldsTestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -16,17 +16,17 @@
import java.util.Collection;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
public int f1;
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
public int f1;
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
public int f1;
}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
index b79d90e..a969d1b 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
@@ -9,14 +9,13 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPublic;
import static com.android.tools.r8.utils.codeinspector.Matchers.isStatic;
import static org.hamcrest.CoreMatchers.allOf;
-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 com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -67,7 +66,7 @@
.allowUnusedProguardConfigurationRules()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
@@ -104,7 +103,7 @@
}
@NeverClassInline
- @NeverMerge
+ @NoVerticalClassMerging
interface Interface {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
index 5b47f4f..9dd4b60 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -45,7 +45,7 @@
" java.lang.String greeting;",
"}")
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getRuntime())
.compile()
.inspect(this::verifyFieldIsPresent)
@@ -82,7 +82,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class A {
public String greeting;
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByReachableSubclassTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByReachableSubclassTest.java
index 2ce88f3..528a4ac 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByReachableSubclassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByReachableSubclassTest.java
@@ -7,7 +7,7 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersBuilder;
@@ -44,7 +44,7 @@
GraphInspector inspector =
testForR8(parameters.getBackend())
.enableGraphInspector()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.addProgramClasses(CLASS, A.class, B.class)
.addKeepMainRule(CLASS)
@@ -72,7 +72,7 @@
}
// Base class, A.foo never resolved to at runtime.
- @NeverMerge
+ @NoVerticalClassMerging
public static class A {
@NeverInline
@@ -82,7 +82,7 @@
}
// Actual and only instantiated type.
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {
@NeverInline
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoMethods.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoMethods.java
index 8a67d39..5bb8e48 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoMethods.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByTwoMethods.java
@@ -6,7 +6,7 @@
import static com.android.tools.r8.references.Reference.methodFromMethod;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -22,7 +22,7 @@
@RunWith(Parameterized.class)
public class KeptByTwoMethods extends TestBase {
- @NeverMerge
+ @NoVerticalClassMerging
public static class A {
@NeverInline
@@ -31,7 +31,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
public static class B extends A {
// Intermediate to A.
}
@@ -72,7 +72,7 @@
GraphInspector inspector =
testForR8(parameters.getBackend())
.enableGraphInspector()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.addKeepMainRule(TestClass.class)
.addProgramClasses(TestClass.class, A.class, B.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSubclassKeepsSuperTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSubclassKeepsSuperTest.java
index 5e7786f..12d1f35 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSubclassKeepsSuperTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSubclassKeepsSuperTest.java
@@ -7,8 +7,8 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersBuilder;
@@ -47,7 +47,7 @@
.enableGraphInspector()
.enableInliningAnnotations()
.enableMemberValuePropagationAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.addProgramClasses(CLASS, Foo.class, Bar.class)
.addKeepMainRule(CLASS)
@@ -66,7 +66,7 @@
barClass.assertPresent().assertKeptBy(fooClass);
}
- @NeverMerge
+ @NoVerticalClassMerging
public abstract static class Bar {}
@NeverClassInline
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 366a97e..4d385a0 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
@@ -12,7 +12,6 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.NeverPropagateValue;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -37,7 +36,6 @@
@RunWith(Parameterized.class)
public class KeptViaClassInitializerTestRunner extends TestBase {
- @NeverMerge
@NeverClassInline
public static class A {
@@ -47,7 +45,6 @@
}
}
- @NeverMerge
@NeverClassInline
public enum T {
A(A::new);
diff --git a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
index 0f8a6bd..bc12cfc 100644
--- a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
@@ -9,7 +9,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -42,7 +42,7 @@
.addKeepMainRule(TestClass.class)
.addOptionsModification(options -> options.enableTreeShakingOfLibraryMethodOverrides = true)
.enableNeverClassInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::verifyOutput)
@@ -95,7 +95,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
static class EscapesIndirectly {
@Override
@@ -106,7 +106,7 @@
static class EscapesIndirectlySub extends EscapesIndirectly {}
- @NeverMerge
+ @NoVerticalClassMerging
static class EscapesIndirectlyWithOverride {
@Override
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/MethodsTestBase.java b/src/test/java/com/android/tools/r8/shaking/methods/MethodsTestBase.java
index 7adb908..07be6e7 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/MethodsTestBase.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/MethodsTestBase.java
@@ -4,7 +4,7 @@
package com.android.tools.r8.shaking.methods;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -30,7 +30,7 @@
List<String> keepRules, BiConsumer<CodeInspector, Shrinker> inspector, String expected)
throws Throwable {
testForR8(Backend.DEX)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addProgramClasses(getClasses())
.addKeepRules(keepRules)
.compile()
@@ -43,7 +43,7 @@
List<String> keepRules, BiConsumer<CodeInspector, Shrinker> inspector, String expected)
throws Throwable {
testForR8Compat(Backend.DEX)
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.addProgramClasses(getClasses())
.addKeepRules(keepRules)
.compile()
@@ -57,7 +57,7 @@
throws Throwable {
testForProguard()
.addProgramClasses(getClasses())
- .addProgramClasses(NeverMerge.class)
+ .addProgramClasses(NoVerticalClassMerging.class)
.addKeepRules(keepRules)
.compile()
.inspect(i -> inspector.accept(i, Shrinker.Proguard))
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
index 8944bb6..9fe2a68 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/abst/AbstractMethodsTest.java
@@ -9,7 +9,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.methods.MethodsTestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -20,17 +20,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
abstract class Super {
public abstract void m1();
}
-@NeverMerge
+@NoVerticalClassMerging
abstract class Sub extends Super {
public abstract void m2();
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
public void m1() {}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
index ddeff6d..2ce8046 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pblc/PublicMethodsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.methods.MethodsTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -18,17 +18,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
public void m1() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
public void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
public void m3() {}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
index ef4e527..e2f3886 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/pckg/PackageMethodsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.methods.MethodsTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -17,17 +17,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
void m1() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
void m3() {}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
index 98be19a..bb5b668 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/prvt/PrivateMethodsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.methods.MethodsTestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -18,17 +18,17 @@
import java.util.Set;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
private void m1() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
private void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
private void m3() {}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
index e10cca9..5f8bc2e 100644
--- a/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/methods/shadow/ShadowMethodsTest.java
@@ -8,7 +8,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.shaking.methods.MethodsTestBase;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -17,19 +17,19 @@
import java.util.Collection;
import org.junit.Test;
-@NeverMerge
+@NoVerticalClassMerging
class Super {
public void m1() {}
private void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class Sub extends Super {
public void m1() {}
private void m2() {}
}
-@NeverMerge
+@NoVerticalClassMerging
class SubSub extends Sub {
public void m1() {}
public void m2() {}
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/A.java b/src/test/java/com/android/tools/r8/shaking/testrules/A.java
index cf97eeb..4536cd9 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/A.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/A.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.shaking.testrules;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoStaticClassMerging;
-@NeverMerge
+@NoStaticClassMerging
public class A {
public static int m(int a, int b) {
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 382ee13..41533ec 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)
+ .enableNoStaticClassMergingAnnotations()
.enableProguardTestOptions()
.compile()
.inspector();
@@ -53,7 +54,6 @@
runTest(
ImmutableList.of(
"-keep class **.Main { *; }",
- "-nevermerge @com.android.tools.r8.NeverMerge class *",
"-neverinline class *{ @com.android.tools.r8.NeverInline <methods>;}",
"-dontobfuscate"));
@@ -84,7 +84,6 @@
"-neverinline class **.A { method(); }",
"-neverinline class **.B { method(); }",
"-keep class **.Main { *; }",
- "-nevermerge @com.android.tools.r8.NeverMerge class *",
"-neverinline class *{ @com.android.tools.r8.NeverInline <methods>;}",
"-dontobfuscate"));
@@ -112,7 +111,6 @@
"-forceinline class **.A { int m(int, int); }",
"-forceinline class **.B { int m(int, int); }",
"-keep class **.Main { *; }",
- "-nevermerge @com.android.tools.r8.NeverMerge class *",
"-neverinline class *{ @com.android.tools.r8.NeverInline <methods>;}",
"-dontobfuscate"));
@@ -130,7 +128,6 @@
ImmutableList.of(
"-forceinline class **.A { int x(); }",
"-keep class **.Main { *; }",
- "-nevermerge @com.android.tools.r8.NeverMerge class *",
"-dontobfuscate"));
fail("Force inline of non-inlinable method succeeded");
} catch (Throwable t) {
diff --git a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
index 39d3aaf..79c5edc 100644
--- a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
@@ -9,7 +9,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.references.Reference;
@@ -53,7 +53,7 @@
"-whyareyoukeeping class **.*$" + targetClass.getSimpleName() + " { void gone(); }")
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.minification(minification)
.setMinApi(AndroidApiLevel.B)
// Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
@@ -71,7 +71,7 @@
.addKeepMainRule(main)
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
- .enableMergeAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
.minification(minification)
.setMinApi(AndroidApiLevel.B)
.setKeptGraphConsumer(graphConsumer)
@@ -114,7 +114,7 @@
testViaConsumer(TestMain2.class, Itf.class, Impl.class);
}
- @NeverMerge
+ @NoVerticalClassMerging
static class Base {
@NeverInline
public void gone() {
@@ -137,7 +137,7 @@
}
}
- @NeverMerge
+ @NoVerticalClassMerging
interface Itf {
void gone();
}
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 04a8671..fe4d4d9 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
@@ -12,6 +12,7 @@
import java.util.List;
import java.util.function.Consumer;
import kotlinx.metadata.jvm.KotlinClassMetadata;
+import org.junit.rules.TemporaryFolder;
public class AbsentClassSubject extends ClassSubject {
@@ -96,7 +97,7 @@
@Override
public String getOriginalName() {
- return null;
+ return reference.getTypeName();
}
@Override
@@ -190,7 +191,12 @@
}
@Override
- public void disassembleUsingJavap(boolean verbose) throws Exception {
+ public String disassembleUsingJavap(boolean verbose) throws Exception {
throw new Unreachable("Cannot disassembly an absent class");
}
+
+ @Override
+ public String asmify(TemporaryFolder tempFolder, boolean debug) throws Exception {
+ throw new Unreachable("Cannot asmify an absent class");
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
index c62f945..f81dffd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
@@ -74,6 +74,11 @@
}
@Override
+ public boolean isSynchronized() {
+ throw new Unreachable("Cannot determine if an absent method is synchronized");
+ }
+
+ @Override
public boolean isInstanceInitializer() {
throw new Unreachable("Cannot determine if an absent method is an instance initializer");
}
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 6cf80fb..4e6a3f5 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
@@ -351,7 +351,6 @@
return instruction instanceof CfArrayStore;
}
-
@Override
public int size() {
// TODO(b/122302789): CfInstruction#getSize()
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 d3c1ecc..96b0d0c 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
@@ -25,6 +25,7 @@
import java.util.function.Consumer;
import java.util.function.Predicate;
import kotlinx.metadata.jvm.KotlinClassMetadata;
+import org.junit.rules.TemporaryFolder;
public abstract class ClassSubject extends Subject {
@@ -217,5 +218,7 @@
public abstract ClassNamingForNameMapper getNaming();
- public abstract void disassembleUsingJavap(boolean verbose) throws Exception;
+ public abstract String disassembleUsingJavap(boolean verbose) throws Exception;
+
+ public abstract String asmify(TemporaryFolder tempFolder, boolean debug) throws Exception;
}
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 8d925da..dbdff3d 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
@@ -30,10 +30,14 @@
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import java.io.File;
+import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import kotlinx.metadata.jvm.KotlinClassMetadata;
+import org.junit.rules.TemporaryFolder;
public class FoundClassSubject extends ClassSubject {
@@ -191,7 +195,7 @@
public FieldSubject uniqueFieldWithName(String name) {
FieldSubject fieldSubject = null;
for (FoundFieldSubject candidate : allFields()) {
- if (candidate.getOriginalName().equals(name)) {
+ if (candidate.getOriginalName(false).equals(name)) {
assert fieldSubject == null;
fieldSubject = candidate;
}
@@ -424,7 +428,7 @@
}
@Override
- public void disassembleUsingJavap(boolean verbose) throws Exception {
+ public String disassembleUsingJavap(boolean verbose) throws Exception {
assert dexClass.origin != null;
List<String> command = new ArrayList<>();
command.add(
@@ -442,5 +446,34 @@
ProcessResult processResult = ToolHelper.runProcess(new ProcessBuilder(command));
assert processResult.exitCode == 0;
System.out.println(processResult.stdout);
+ return processResult.stdout;
+ }
+
+ @Override
+ public String asmify(TemporaryFolder tempFolder, boolean debug) throws Exception {
+ assert dexClass.origin != null;
+ List<String> parts = dexClass.origin.parts();
+ assert parts.size() == 2;
+ String directory = parts.get(0);
+ String fileName = parts.get(1);
+ if (directory.endsWith(".jar") || directory.endsWith(".zip")) {
+ File tempOut = tempFolder.newFolder();
+ ZipUtils.unzip(directory, tempOut);
+ directory = tempOut.getAbsolutePath();
+ }
+ List<String> command = new ArrayList<>();
+ command.add(
+ CfRuntime.getCheckedInJdk9().getJavaHome().resolve("bin").resolve("java").toString());
+ command.add("-cp");
+ command.add(ToolHelper.ASM_JAR + ":" + ToolHelper.ASM_UTIL_JAR);
+ command.add("org.objectweb.asm.util.ASMifier");
+ if (!debug) {
+ command.add("-debug");
+ }
+ command.add(Paths.get(directory, fileName).toString());
+ ProcessResult processResult = ToolHelper.runProcess(new ProcessBuilder(command));
+ assert processResult.exitCode == 0;
+ System.out.println(processResult.stdout);
+ return processResult.stdout;
}
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
index 299a6c0..536aa5e3 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
@@ -122,6 +122,11 @@
}
@Override
+ public boolean isSynchronized() {
+ return dexMethod.accessFlags.isSynchronized();
+ }
+
+ @Override
public boolean isInstanceInitializer() {
return dexMethod.isInstanceInitializer();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
index f2b7fe3..04f007b 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.utils.codeinspector;
+import static org.hamcrest.CoreMatchers.not;
+
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AccessFlags;
import com.android.tools.r8.graph.DexClass;
@@ -107,7 +109,7 @@
@Override
public void describeTo(final Description description) {
- description.appendText(" present");
+ description.appendText("present");
}
@Override
@@ -660,4 +662,11 @@
return getClassName() + "." + getMethodName() + "(" + filename + ":" + originalPosition + ")";
}
}
+
+ public static <T> Matcher<T> notIf(Matcher<T> matcher, boolean condition) {
+ if (condition) {
+ return not(matcher);
+ }
+ return matcher;
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
index 690838d..3c86361 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
@@ -25,6 +25,8 @@
public abstract boolean isBridge();
+ public abstract boolean isSynchronized();
+
public abstract boolean isInstanceInitializer();
public abstract boolean isClassInitializer();
diff --git a/tools/test.py b/tools/test.py
index 5bc9d6c..fbc1985 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -138,6 +138,9 @@
result.add_option('--worktree',
default=False, action='store_true',
help='Tests are run in worktree and should not use gradle user home.')
+ result.add_option('--horizontal-class-merging', '--horizontal_class_merging',
+ help='Enable horizontal class merging.',
+ default=False, action='store_true')
result.add_option('--runtimes',
default=None,
help='Test parameter runtimes to use, separated by : (eg, none:jdk9).'
