Merge commit '9ffdfb9a9dd243e5af5eb377ec7ff1efdc413707' into dev-release
diff --git a/.gitignore b/.gitignore
index 07f90a7..885f76d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -231,6 +231,8 @@
third_party/r8mappings.tar.gz
third_party/remapper
third_party/remapper.tar.gz
+third_party/retrace
+third_party/retrace.tar.gz
third_party/retrace_benchmark
third_party/retrace_benchmark.tar.gz
third_party/retrace_internal
diff --git a/build.gradle b/build.gradle
index 8b0525f..08c9141 100644
--- a/build.gradle
+++ b/build.gradle
@@ -346,6 +346,7 @@
"proguard/proguard5.2.1",
"proguard/proguard6.0.1",
"proguard/proguard-7.0.0",
+ "retrace/binary_compatibility",
"r8",
"r8-releases/2.0.74",
"r8mappings",
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 91f6172..2ab471a 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -473,7 +473,7 @@
// We can now remove visibility bridges. Note that we do not need to update the
// invoke-targets here, as the existing invokes will simply dispatch to the now
// visible super-method. MemberRebinding, if run, will then dispatch it correctly.
- new VisibilityBridgeRemover(appView.withLiveness()).run();
+ new VisibilityBridgeRemover(appView.withLiveness()).run(executorService);
}
}
@@ -720,7 +720,7 @@
// Remove unneeded visibility bridges that have been inserted for member rebinding.
// This can only be done if we have AppInfoWithLiveness.
if (appView.appInfo().hasLiveness()) {
- new VisibilityBridgeRemover(appView.withLiveness()).run();
+ new VisibilityBridgeRemover(appView.withLiveness()).run(executorService);
} else {
// If we don't have AppInfoWithLiveness here, it must be because we are not shrinking. When
// we are not shrinking, we can't move visibility bridges. In principle, though, it would be
diff --git a/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java b/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
index fdec52c..ab9165b 100644
--- a/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfCodePrinter.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.cf.code.CfCheckCast;
import com.android.tools.r8.cf.code.CfCmp;
import com.android.tools.r8.cf.code.CfConstClass;
+import com.android.tools.r8.cf.code.CfConstDynamic;
import com.android.tools.r8.cf.code.CfConstMethodHandle;
import com.android.tools.r8.cf.code.CfConstMethodType;
import com.android.tools.r8.cf.code.CfConstNull;
@@ -388,6 +389,12 @@
}
@Override
+ public void print(CfConstDynamic constDynamic) {
+ // TODO(b/198143561): Support CfConstDynamic.
+ throw new Unimplemented(constDynamic.getClass().getSimpleName());
+ }
+
+ @Override
public void print(CfReturnVoid ret) {
printNewInstruction("CfReturnVoid");
}
diff --git a/src/main/java/com/android/tools/r8/cf/CfPrinter.java b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
index c6ba520..480c9cb 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.cf.code.CfCheckCast;
import com.android.tools.r8.cf.code.CfCmp;
import com.android.tools.r8.cf.code.CfConstClass;
+import com.android.tools.r8.cf.code.CfConstDynamic;
import com.android.tools.r8.cf.code.CfConstMethodHandle;
import com.android.tools.r8.cf.code.CfConstMethodType;
import com.android.tools.r8.cf.code.CfConstNull;
@@ -326,6 +327,12 @@
appendType(constClass.getType());
}
+ public void print(CfConstDynamic constDynamic) {
+ indent();
+ builder.append("ldc <dynamic> ");
+ appendType(constDynamic.getType());
+ }
+
public void print(CfInitClass initClass) {
indent();
builder.append("initclass ");
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java b/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java
new file mode 100644
index 0000000..e6e1f0d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java
@@ -0,0 +1,232 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.cf.code;
+
+import static com.android.tools.r8.graph.UseRegistry.MethodHandleUse.NOT_ARGUMENT_TO_LAMBDA_METAFACTORY;
+
+import com.android.tools.r8.cf.CfPrinter;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.CfCompareHelper;
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexMethodHandle;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.InitClassLens;
+import com.android.tools.r8.graph.JarApplicationReader;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.ir.conversion.CfSourceCode;
+import com.android.tools.r8.ir.conversion.CfState;
+import com.android.tools.r8.ir.conversion.IRBuilder;
+import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicReference;
+import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.utils.structural.CompareToVisitor;
+import java.util.ListIterator;
+import org.objectweb.asm.ConstantDynamic;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class CfConstDynamic extends CfInstruction implements CfTypeInstruction {
+
+ private final ConstantDynamicReference reference;
+
+ public CfConstDynamic(
+ DexString name,
+ DexType type,
+ DexMethodHandle bootstrapMethod,
+ Object[] bootstrapMethodArguments) {
+ assert name != null;
+ assert type != null;
+ assert bootstrapMethod != null;
+ assert bootstrapMethodArguments != null;
+ assert bootstrapMethodArguments.length == 0;
+
+ reference = new ConstantDynamicReference(name, type, bootstrapMethod, bootstrapMethodArguments);
+ }
+
+ @Override
+ public CfConstDynamic asConstDynamic() {
+ return this;
+ }
+
+ @Override
+ public boolean isConstDynamic() {
+ return true;
+ }
+
+ public ConstantDynamicReference getReference() {
+ return reference;
+ }
+
+ public DexString getName() {
+ return reference.getName();
+ }
+
+ public DexMethodHandle getBootstrapMethod() {
+ return reference.getBootstrapMethod();
+ }
+
+ public Object[] getBootstrapMethodArguments() {
+ return reference.getBootstrapMethodArguments();
+ }
+
+ public static CfConstDynamic fromAsmConstantDynamic(
+ ConstantDynamic insn, JarApplicationReader application, DexType clazz) {
+ String constantName = insn.getName();
+ String constantDescriptor = insn.getDescriptor();
+ // TODO(b/178172809): Handle bootstrap arguments.
+ if (insn.getBootstrapMethodArgumentCount() > 0) {
+ throw new CompilationError(
+ "Unsupported dynamic constant (has arguments to bootstrap method)");
+ }
+ if (insn.getBootstrapMethod().getTag() != Opcodes.H_INVOKESTATIC) {
+ throw new CompilationError("Unsupported dynamic constant (not invoke static)");
+ }
+ if (insn.getBootstrapMethod().getOwner().equals("java/lang/invoke/ConstantBootstraps")) {
+ throw new CompilationError(
+ "Unsupported dynamic constant (runtime provided bootstrap method)");
+ }
+ if (application.getTypeFromName(insn.getBootstrapMethod().getOwner()) != clazz) {
+ throw new CompilationError("Unsupported dynamic constant (different owner)");
+ }
+ // Resolve the bootstrap method.
+ DexMethodHandle bootstrapMethodHandle =
+ DexMethodHandle.fromAsmHandle(insn.getBootstrapMethod(), application, clazz);
+ if (!bootstrapMethodHandle.member.isDexMethod()) {
+ throw new CompilationError("Unsupported dynamic constant (invalid method handle)");
+ }
+ DexMethod bootstrapMethod = bootstrapMethodHandle.asMethod();
+ if (bootstrapMethod.getProto().returnType != application.getTypeFromDescriptor("[Z")
+ && bootstrapMethod.getProto().returnType
+ != application.getTypeFromDescriptor("Ljava/lang/Object;")) {
+ throw new CompilationError("Unsupported dynamic constant (unsupported constant type)");
+ }
+ if (bootstrapMethod.getProto().getParameters().size() != 3) {
+ throw new CompilationError("Unsupported dynamic constant (unsupported signature)");
+ }
+ if (bootstrapMethod.getProto().getParameters().get(0) != application.getFactory().lookupType) {
+ throw new CompilationError(
+ "Unsupported dynamic constant (unexpected type of first argument to bootstrap method");
+ }
+ if (bootstrapMethod.getProto().getParameters().get(1) != application.getFactory().stringType) {
+ throw new CompilationError(
+ "Unsupported dynamic constant (unexpected type of second argument to bootstrap method");
+ }
+ if (bootstrapMethod.getProto().getParameters().get(2) != application.getFactory().classType) {
+ throw new CompilationError(
+ "Unsupported dynamic constant (unexpected type of third argument to bootstrap method");
+ }
+ return new CfConstDynamic(
+ application.getString(constantName),
+ application.getTypeFromDescriptor(constantDescriptor),
+ bootstrapMethodHandle,
+ new Object[] {});
+ }
+
+ @Override
+ public int getCompareToId() {
+ return CfCompareHelper.CONST_DYNAMIC_COMPARE_ID;
+ }
+
+ @Override
+ public int internalAcceptCompareTo(
+ CfInstruction other, CompareToVisitor visitor, CfCompareHelper helper) {
+ int diff = getName().acceptCompareTo(((CfConstDynamic) other).getName(), visitor);
+ if (diff != 0) {
+ return diff;
+ }
+ diff = getType().acceptCompareTo(((CfConstDynamic) other).getType(), visitor);
+ if (diff != 0) {
+ return diff;
+ }
+ return getBootstrapMethod()
+ .acceptCompareTo(((CfConstDynamic) other).getBootstrapMethod(), visitor);
+ }
+
+ @Override
+ public CfTypeInstruction asTypeInstruction() {
+ return this;
+ }
+
+ @Override
+ public boolean isTypeInstruction() {
+ return true;
+ }
+
+ @Override
+ public DexType getType() {
+ return reference.getType();
+ }
+
+ @Override
+ public CfInstruction withType(DexType newType) {
+ throw new Unimplemented();
+ }
+
+ @Override
+ public void write(
+ AppView<?> appView,
+ ProgramMethod context,
+ DexItemFactory dexItemFactory,
+ GraphLens graphLens,
+ InitClassLens initClassLens,
+ NamingLens namingLens,
+ LensCodeRewriterUtils rewriter,
+ MethodVisitor visitor) {
+ // TODO(b/198142625): Support CONSTANT_Dynamic for R8 cf to cf.
+ throw new CompilationError("Unsupported dynamic constant (not desugaring)");
+ }
+
+ @Override
+ public void print(CfPrinter printer) {
+ printer.print(this);
+ }
+
+ @Override
+ public boolean canThrow() {
+ return true;
+ }
+
+ @Override
+ void internalRegisterUse(
+ UseRegistry registry, DexClassAndMethod context, ListIterator<CfInstruction> iterator) {
+ registry.registerTypeReference(reference.getType());
+ registry.registerMethodHandle(
+ reference.getBootstrapMethod(), NOT_ARGUMENT_TO_LAMBDA_METAFACTORY);
+ assert reference.getBootstrapMethodArguments().length == 0;
+ }
+
+ @Override
+ public void buildIR(IRBuilder builder, CfState state, CfSourceCode code) {
+ throw new CompilationError("Unsupported dynamic constant (not desugaring)");
+ }
+
+ @Override
+ public ConstraintWithTarget inliningConstraint(
+ InliningConstraints inliningConstraints, CfCode code, ProgramMethod context) {
+ throw new Unreachable();
+ }
+
+ @Override
+ public void evaluate(
+ CfFrameVerificationHelper frameBuilder,
+ DexType context,
+ DexType returnType,
+ DexItemFactory factory,
+ InitClassLens initClassLens) {
+ // ... →
+ // ..., value
+ frameBuilder.push(factory.classType);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
index 6067cc3..188c575 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
@@ -118,6 +118,14 @@
return false;
}
+ public CfConstDynamic asConstDynamic() {
+ return null;
+ }
+
+ public boolean isConstDynamic() {
+ return false;
+ }
+
public CfFieldInstruction asFieldInstruction() {
return null;
}
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 c8b99a4..dc8e0bb 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
@@ -465,7 +465,7 @@
}
assert potentialHolder.isInterface();
for (DexEncodedMethod virtualMethod : potentialHolder.virtualMethods()) {
- if (virtualMethod.getReference().hasSameProtoAndName(method.getReference())
+ if (virtualMethod.getReference().match(method.getReference())
&& virtualMethod.accessFlags.isSameVisibility(method.accessFlags)) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/graph/CfCompareHelper.java b/src/main/java/com/android/tools/r8/graph/CfCompareHelper.java
index 1108c72..d3c3351 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCompareHelper.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCompareHelper.java
@@ -25,6 +25,7 @@
public static final int CONST_NUMBER_COMPARE_ID;
public static final int CONST_METHOD_TYPE_COMPARE_ID;
public static final int CONST_METHOD_HANDLE_COMPARE_ID;
+ public static final int CONST_DYNAMIC_COMPARE_ID;
public static final int FRAME_COMPARE_ID;
public static final int INIT_CLASS_COMPARE_ID;
public static final int LABEL_COMPARE_ID;
@@ -38,6 +39,7 @@
CONST_NUMBER_COMPARE_ID = ++lastId;
CONST_METHOD_TYPE_COMPARE_ID = ++lastId;
CONST_METHOD_HANDLE_COMPARE_ID = ++lastId;
+ CONST_DYNAMIC_COMPARE_ID = ++lastId;
FRAME_COMPARE_ID = ++lastId;
INIT_CLASS_COMPARE_ID = ++lastId;
LABEL_COMPARE_ID = ++lastId;
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index 2b8a186..5efaba3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -374,6 +374,10 @@
this.genericSignature = FieldTypeSignature.noSignature();
}
+ public static Builder builder() {
+ return new Builder();
+ }
+
private static Builder builder(DexEncodedField from) {
return new Builder(from);
}
@@ -381,16 +385,18 @@
public static class Builder {
private DexField field;
- private DexAnnotationSet annotations;
+ private DexAnnotationSet annotations = DexAnnotationSet.empty();
private FieldAccessFlags accessFlags;
- private FieldTypeSignature genericSignature;
+ private FieldTypeSignature genericSignature = FieldTypeSignature.noSignature();
private DexValue staticValue;
private AndroidApiLevel apiLevel;
- private FieldOptimizationInfo optimizationInfo;
+ private FieldOptimizationInfo optimizationInfo = DefaultFieldOptimizationInfo.getInstance();
private boolean deprecated;
private boolean d8R8Synthesized;
private Consumer<DexEncodedField> buildConsumer = ConsumerUtils.emptyConsumer();
+ Builder() {}
+
Builder(DexEncodedField from) {
// Copy all the mutable state of a DexEncodedField here.
field = from.getReference();
@@ -445,7 +451,27 @@
return this;
}
- DexEncodedField build() {
+ public Builder setAccessFlags(FieldAccessFlags accessFlags) {
+ this.accessFlags = accessFlags;
+ return this;
+ }
+
+ public Builder setD8R8Synthesized() {
+ this.d8R8Synthesized = true;
+ return this;
+ }
+
+ public Builder setApiLevel(AndroidApiLevel apiLevel) {
+ this.apiLevel = apiLevel;
+ return this;
+ }
+
+ public DexEncodedField build() {
+ assert field != null;
+ assert accessFlags != null;
+ assert genericSignature != null;
+ assert annotations != null;
+ assert apiLevel != null;
DexEncodedField dexEncodedField =
new DexEncodedField(
field,
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 0243703..6cbb223 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -166,8 +166,6 @@
/** Generic signature information if the attribute is present in the input */
private MethodTypeSignature genericSignature;
- private DexEncodedMethod defaultInterfaceMethodImplementation = null;
-
private OptionalBool isLibraryMethodOverride = OptionalBool.unknown();
private Int2ReferenceMap<DebugLocalInfo> parameterInfo = NO_PARAMETER_INFO;
@@ -211,21 +209,6 @@
return compilationState;
}
- public DexEncodedMethod getDefaultInterfaceMethodImplementation() {
- return defaultInterfaceMethodImplementation;
- }
-
- public void setDefaultInterfaceMethodImplementation(DexEncodedMethod implementation) {
- assert defaultInterfaceMethodImplementation == null;
- assert implementation != null;
- assert code != null;
- // TODO(b/183998768): Once R8 desugars in the enqueuer this should always be invalid code.
- assert InvalidCode.isInvalidCode(code) || code == implementation.getCode();
- accessFlags.setAbstract();
- removeCode();
- defaultInterfaceMethodImplementation = implementation;
- }
-
/**
* Flags this method as no longer being obsolete.
*
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 5eaf805..c2eeffa 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -218,14 +218,6 @@
return false;
}
- /**
- * Returns true if the other method has the same name and prototype (including signature and
- * return type), false otherwise.
- */
- public boolean hasSameProtoAndName(DexMethod other) {
- return name == other.name && proto == other.proto;
- }
-
@Override
public boolean match(DexMethod method) {
return match(method.getProto(), method.getName());
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessFlags.java b/src/main/java/com/android/tools/r8/graph/FieldAccessFlags.java
index 850c3cb..29e68bf 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessFlags.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessFlags.java
@@ -71,6 +71,11 @@
Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC);
}
+ public static FieldAccessFlags createPrivateStaticSynthetic() {
+ return fromSharedAccessFlags(
+ Constants.ACC_PRIVATE | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC);
+ }
+
public static FieldAccessFlags createPublicFinalSynthetic() {
return fromSharedAccessFlags(
Constants.ACC_PUBLIC | Constants.ACC_FINAL | Constants.ACC_SYNTHETIC);
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLens.java b/src/main/java/com/android/tools/r8/graph/GraphLens.java
index 37dea58..a81d742 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLens.java
@@ -8,7 +8,6 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.ir.code.Invoke.Type;
import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
-import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor.InterfaceProcessorNestedGraphLens;
import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
import com.android.tools.r8.optimize.MemberRebindingLens;
import com.android.tools.r8.shaking.KeepInfoCollection;
@@ -480,14 +479,6 @@
return null;
}
- public boolean isInterfaceProcessorLens() {
- return false;
- }
-
- public InterfaceProcessorNestedGraphLens asInterfaceProcessorLens() {
- return null;
- }
-
public GraphLens withCodeRewritingsApplied(DexItemFactory dexItemFactory) {
if (hasCodeRewritings()) {
return new ClearCodeRewritingGraphLens(dexItemFactory, this);
diff --git a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
index 55482fc..2f052aa 100644
--- a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
+++ b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
@@ -516,10 +516,6 @@
if (!accessFlags.isRecord()) {
return;
}
- // TODO(b/169645628): Support records in all compilation.
- if (!application.options.enableExperimentalRecordDesugaring()) {
- throw new CompilationError("Records are not supported", origin);
- }
// TODO(b/169645628): Change this logic if we start stripping the record components.
// Another approach would be to mark a bit in fields that are record components instead.
String message = "Records are expected to have one record component per instance field.";
diff --git a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
index 174dca5..c554ca5 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.cf.code.CfCheckCast;
import com.android.tools.r8.cf.code.CfCmp;
import com.android.tools.r8.cf.code.CfConstClass;
+import com.android.tools.r8.cf.code.CfConstDynamic;
import com.android.tools.r8.cf.code.CfConstMethodHandle;
import com.android.tools.r8.cf.code.CfConstMethodType;
import com.android.tools.r8.cf.code.CfConstNull;
@@ -887,7 +888,9 @@
new CfConstMethodHandle(
DexMethodHandle.fromAsmHandle((Handle) cst, application, method.holder)));
} else if (cst instanceof ConstantDynamic) {
- throw new CompilationError("Unsupported dynamic constant: " + cst.toString());
+ instructions.add(
+ CfConstDynamic.fromAsmConstantDynamic(
+ (ConstantDynamic) cst, application, method.holder));
} else {
throw new CompilationError("Unsupported constant: " + cst.toString());
}
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
index 7f09192..459c008 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectAllocationInfoCollectionImpl.java
@@ -534,7 +534,8 @@
private boolean verifyAllSuperTypesAreInHierarchy(
DexDefinitionSupplier definitions, Iterable<DexType> dexTypes) {
for (DexType supertype : dexTypes) {
- assert typeIsInHierarchy(definitions, supertype);
+ assert typeIsInHierarchy(definitions, supertype)
+ : "Type not found in hierarchy: " + supertype;
}
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 c00f43c..8f6f293 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
@@ -4,7 +4,6 @@
package com.android.tools.r8.ir.conversion;
import static com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor.ExcludeDexResources;
-import static com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor.IncludeAllResources;
import static com.android.tools.r8.ir.desugar.lambda.D8LambdaDesugaring.rewriteEnclosingLambdaMethodAttributes;
import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
@@ -58,7 +57,6 @@
import com.android.tools.r8.ir.desugar.itf.EmulatedInterfaceApplicationRewriter;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter;
-import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
import com.android.tools.r8.ir.desugar.lambda.LambdaDeserializationMethodRemover;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
@@ -362,23 +360,6 @@
}
}
- private void finalizeInterfaceMethodRewritingThroughIR(ExecutorService executorService)
- throws ExecutionException {
- assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
- if (interfaceMethodRewriter != null) {
- interfaceMethodRewriter.finalizeInterfaceMethodRewritingThroughIR(this, executorService);
- }
- }
-
- private void runInterfaceDesugaringProcessorsForR8(
- Flavor includeAllResources, ExecutorService executorService) throws ExecutionException {
- assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
- if (interfaceMethodRewriter != null) {
- interfaceMethodRewriter.runInterfaceDesugaringProcessorsForR8(
- this, includeAllResources, executorService);
- }
- }
-
private void processCovariantReturnTypeAnnotations(Builder<?> builder) {
if (covariantReturnTypeAnnotationTransformer != null) {
covariantReturnTypeAnnotationTransformer.process(builder);
@@ -460,10 +441,11 @@
CfPostProcessingDesugaringEventConsumer.createForD8(methodProcessor, instructionDesugaring);
methodProcessor.newWave();
InterfaceMethodProcessorFacade interfaceDesugaring =
- instructionDesugaring.getInterfaceMethodPostProcessingDesugaring(ExcludeDexResources);
+ instructionDesugaring.getInterfaceMethodPostProcessingDesugaringD8(ExcludeDexResources);
CfPostProcessingDesugaringCollection.create(
appView, interfaceDesugaring, instructionDesugaring.getRetargetingInfo())
- .postProcessingDesugaring(appView.appInfo().classes(), eventConsumer, executorService);
+ .postProcessingDesugaring(
+ appView.appInfo().classes(), m -> true, eventConsumer, executorService);
methodProcessor.awaitMethodProcessing();
eventConsumer.finalizeDesugaring();
}
@@ -789,11 +771,6 @@
Builder<?> builder = appView.appInfo().app().builder();
builder.setHighestSortingString(highestSortingString);
- printPhase("Interface method desugaring");
- finalizeInterfaceMethodRewritingThroughIR(executorService);
- runInterfaceDesugaringProcessorsForR8(IncludeAllResources, executorService);
- feedback.updateVisibleOptimizationInfo();
-
if (serviceLoaderRewriter != null) {
processSynthesizedServiceLoaderMethods(
serviceLoaderRewriter.getServiceLoadMethods(), executorService);
@@ -1466,14 +1443,6 @@
previous = printMethod(code, "IR after class inlining (SSA)", previous);
- // TODO(b/183998768): Enable interface method rewriter cf to cf also in R8.
- if (interfaceMethodRewriter != null && appView.enableWholeProgramOptimizations()) {
- timing.begin("Rewrite interface methods");
- interfaceMethodRewriter.rewriteMethodReferences(
- code, methodProcessor, methodProcessingContext);
- timing.end();
- }
-
assert code.verifyTypes(appView);
previous = printMethod(code, "IR after interface method rewriting (SSA)", previous);
@@ -1504,12 +1473,15 @@
timing.begin("Canonicalize constants");
constantCanonicalizer.canonicalize(appView, code);
timing.end();
+ previous = printMethod(code, "IR after constant canonicalization (SSA)", previous);
timing.begin("Create constants for literal instructions");
codeRewriter.useDedicatedConstantForLitInstruction(code);
timing.end();
+ previous = printMethod(code, "IR after constant literals (SSA)", previous);
timing.begin("Shorten live ranges");
codeRewriter.shortenLiveRanges(code);
timing.end();
+ previous = printMethod(code, "IR after shorten live ranges (SSA)", previous);
}
timing.begin("Canonicalize idempotent calls");
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index 837d5fc..73f0fe5 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -707,9 +707,8 @@
DexType oldType,
DexType newType,
Value initialValue) {
- if (initialValue.isConstNumber()
- && initialValue.definition.asConstNumber().isZero()
- && defaultValueHasChanged(oldType, newType)) {
+ if (initialValue.getType().isNullType() && defaultValueHasChanged(oldType, newType)) {
+ assert newType.isIntType();
iterator.previous();
Value rewrittenDefaultValue =
iterator.insertConstNumberInstruction(
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
index 10032bc..5d4f7b6 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
@@ -11,9 +11,11 @@
import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
+import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.utils.ThrowingConsumer;
import java.util.function.Consumer;
+import java.util.function.Predicate;
/**
* Abstracts a collection of low-level desugarings (i.e., mappings from class-file instructions to
@@ -60,9 +62,12 @@
public abstract <T extends Throwable> void withD8NestBasedAccessDesugaring(
ThrowingConsumer<D8NestBasedAccessDesugaring, T> consumer) throws T;
- public abstract InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaring(
+ public abstract InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringD8(
Flavor flavor);
+ public abstract InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringR8(
+ Flavor flavor, Predicate<ProgramMethod> isLiveMethod, InterfaceProcessor processor);
+
public abstract RetargetingInfo getRetargetingInfo();
public abstract void withDesugaredLibraryAPIConverter(
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
index 4f6dd6c..2493dd3 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
@@ -14,6 +14,8 @@
import com.android.tools.r8.ir.conversion.ClassConverterResult;
import com.android.tools.r8.ir.conversion.D8MethodProcessor;
import com.android.tools.r8.ir.desugar.backports.BackportedMethodDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicClass;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterSynthesizerEventConsumer.DesugaredLibraryRetargeterInstructionEventConsumer;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryAPIConverterEventConsumer;
import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialBridgeInfo;
@@ -45,6 +47,7 @@
implements BackportedMethodDesugaringEventConsumer,
InvokeSpecialToSelfDesugaringEventConsumer,
LambdaDesugaringEventConsumer,
+ ConstantDynamicDesugaringEventConsumer,
NestBasedAccessDesugaringEventConsumer,
RecordInstructionDesugaringEventConsumer,
TwrCloseResourceDesugaringEventConsumer,
@@ -61,16 +64,32 @@
public static R8CfInstructionDesugaringEventConsumer createForR8(
AppView<? extends AppInfoWithClassHierarchy> appView,
BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer,
+ BiConsumer<ConstantDynamicClass, ProgramMethod> constantDynamicClassConsumer,
BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer,
- SyntheticAdditions additions) {
+ SyntheticAdditions additions,
+ BiConsumer<ProgramMethod, ProgramMethod> companionMethodConsumer) {
return new R8CfInstructionDesugaringEventConsumer(
- appView, lambdaClassConsumer, twrCloseResourceMethodConsumer, additions);
+ appView,
+ lambdaClassConsumer,
+ constantDynamicClassConsumer,
+ twrCloseResourceMethodConsumer,
+ additions,
+ companionMethodConsumer);
}
+ // TODO(b/183998768): Remove this event consumer. It should be unneeded for R8 and for D8 the
+ // desugaring of interface methods should be able to happen up front too avoiding the companion
+ // callback on nest accessors.
public static CfInstructionDesugaringEventConsumer createForDesugaredCode() {
return new CfInstructionDesugaringEventConsumer() {
@Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companionMethod) {
+ // A synthesized nest based accessor may itself be defined on an interface, in which case
+ // desugaring the accessor will result in a rewrite to the companion method.
+ }
+
+ @Override
public void acceptClasspathEmulatedInterface(DexClasspathClass clazz) {
assert false;
}
@@ -127,6 +146,12 @@
}
@Override
+ public void acceptConstantDynamicClass(
+ ConstantDynamicClass constantDynamicClass, ProgramMethod context) {
+ assert false;
+ }
+
+ @Override
public void acceptNestFieldGetBridge(ProgramField target, ProgramMethod bridge) {
assert false;
}
@@ -161,12 +186,18 @@
private final Map<DexReference, InvokeSpecialBridgeInfo> pendingInvokeSpecialBridges =
new LinkedHashMap<>();
private final List<LambdaClass> synthesizedLambdaClasses = new ArrayList<>();
+ private final List<ConstantDynamicClass> synthesizedConstantDynamicClasses = new ArrayList<>();
private D8CfInstructionDesugaringEventConsumer(D8MethodProcessor methodProcessor) {
this.methodProcessor = methodProcessor;
}
@Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companionMethod) {
+ // Intentionally empty. Methods are moved when processing the interface definition.
+ }
+
+ @Override
public void acceptDesugaredLibraryRetargeterDispatchClasspathClass(DexClasspathClass clazz) {
// Intentionally empty.
}
@@ -207,6 +238,14 @@
}
@Override
+ public void acceptConstantDynamicClass(
+ ConstantDynamicClass constantDynamicClass, ProgramMethod context) {
+ synchronized (synthesizedConstantDynamicClasses) {
+ synthesizedConstantDynamicClasses.add(constantDynamicClass);
+ }
+ }
+
+ @Override
public void acceptNestFieldGetBridge(ProgramField target, ProgramMethod bridge) {
assert false;
}
@@ -257,6 +296,7 @@
List<ProgramMethod> needsProcessing = new ArrayList<>();
finalizeInvokeSpecialDesugaring(appView, needsProcessing::add);
finalizeLambdaDesugaring(classConverterResultBuilder, needsProcessing::add);
+ finalizeConstantDynamicDesugaring(needsProcessing::add);
return needsProcessing;
}
@@ -299,6 +339,13 @@
synthesizedLambdaClasses.clear();
}
+ private void finalizeConstantDynamicDesugaring(Consumer<ProgramMethod> needsProcessing) {
+ for (ConstantDynamicClass constantDynamicClass : synthesizedConstantDynamicClasses) {
+ constantDynamicClass.getConstantDynamicProgramClass().forEachProgramMethod(needsProcessing);
+ }
+ synthesizedLambdaClasses.clear();
+ }
+
public boolean verifyNothingToFinalize() {
assert pendingInvokeSpecialBridges.isEmpty();
assert synthesizedLambdaClasses.isEmpty();
@@ -311,25 +358,39 @@
private final AppView<? extends AppInfoWithClassHierarchy> appView;
- // TODO(b/180091213): Remove these two consumers when synthesizing contexts are accessible from
+ // TODO(b/180091213): Remove these three consumers when synthesizing contexts are accessible
+ // from
// synthetic items.
private final BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer;
+ private final BiConsumer<ConstantDynamicClass, ProgramMethod> constantDynamicClassConsumer;
private final BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer;
private final SyntheticAdditions additions;
private final Map<LambdaClass, ProgramMethod> synthesizedLambdaClasses =
new IdentityHashMap<>();
private final List<InvokeSpecialBridgeInfo> pendingInvokeSpecialBridges = new ArrayList<>();
+ private final List<ConstantDynamicClass> synthesizedConstantDynamicClasses = new ArrayList<>();
+
+ private final BiConsumer<ProgramMethod, ProgramMethod> onCompanionMethodCallback;
public R8CfInstructionDesugaringEventConsumer(
AppView<? extends AppInfoWithClassHierarchy> appView,
BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer,
+ BiConsumer<ConstantDynamicClass, ProgramMethod> constantDynamicClassConsumer,
BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer,
- SyntheticAdditions additions) {
+ SyntheticAdditions additions,
+ BiConsumer<ProgramMethod, ProgramMethod> onCompanionMethodCallback) {
this.appView = appView;
this.lambdaClassConsumer = lambdaClassConsumer;
+ this.constantDynamicClassConsumer = constantDynamicClassConsumer;
this.twrCloseResourceMethodConsumer = twrCloseResourceMethodConsumer;
this.additions = additions;
+ this.onCompanionMethodCallback = onCompanionMethodCallback;
+ }
+
+ @Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companionMethod) {
+ onCompanionMethodCallback.accept(method, companionMethod);
}
@Override
@@ -344,7 +405,7 @@
@Override
public void acceptCompanionClassClinit(ProgramMethod method) {
- // TODO(b/183998768): Update this once desugaring is moved to the enqueuer.
+ // Intentionally empty. The method will be hit by tracing if required.
}
@Override
@@ -354,19 +415,19 @@
@Override
public void acceptRecordMethod(ProgramMethod method) {
- // Intentionally empty. The method will be hit by the tracing in R8 as if it was
- // present in the input code, and thus nothing needs to be done.
+ // Intentionally empty. The method will be hit by tracing if required.
}
@Override
public void acceptThrowMethod(ProgramMethod method, ProgramMethod context) {
- assert false : "TODO(b/183998768): To be implemented";
+ // Intentionally empty. The method will be hit by tracing if required.
}
@Override
public void acceptInvokeStaticInterfaceOutliningMethod(
ProgramMethod method, ProgramMethod context) {
- assert false : "TODO(b/183998768): To be implemented";
+ // Intentionally empty. The method will be hit by tracing if required.
+ additions.addNeverInlineMethod(method);
}
@Override
@@ -376,14 +437,12 @@
@Override
public void acceptAPIConversion(ProgramMethod method) {
- // Intentionally empty. The method will be hit by the tracing in R8 as if it was
- // present in the input code, and thus nothing needs to be done.
+ // Intentionally empty. The method will be hit by tracing if required.
}
@Override
public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
- // Intentionally empty. The backported method will be hit by the tracing in R8 as if it was
- // present in the input code, and thus nothing needs to be done.
+ // Intentionally empty. The method will be hit by tracing if required.
}
@Override
@@ -404,6 +463,17 @@
}
@Override
+ public void acceptConstantDynamicClass(
+ ConstantDynamicClass constantDynamicClass, ProgramMethod context) {
+ synchronized (synthesizedConstantDynamicClasses) {
+ synthesizedConstantDynamicClasses.add(constantDynamicClass);
+ }
+ // TODO(b/180091213): Remove the recording of the synthesizing context when this is accessible
+ // from synthetic items.
+ constantDynamicClassConsumer.accept(constantDynamicClass, context);
+ }
+
+ @Override
public void acceptNestFieldGetBridge(ProgramField target, ProgramMethod bridge) {
assert false;
}
@@ -420,8 +490,6 @@
@Override
public void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context) {
- // Intentionally empty. The close method will be hit by the tracing in R8 as if they were
- // present in the input code, and thus nothing needs to be done.
// TODO(b/180091213): Remove the recording of the synthesizing context when this is accessible
// from synthetic items.
twrCloseResourceMethodConsumer.accept(closeMethod, context);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
index dbba296..a0d130d 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
@@ -5,6 +5,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPICallbackSynthesizor;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterPostProcessor;
import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
@@ -15,6 +16,7 @@
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import java.util.function.Predicate;
public abstract class CfPostProcessingDesugaringCollection {
@@ -35,6 +37,7 @@
public abstract void postProcessingDesugaring(
Collection<DexProgramClass> programClasses,
+ Predicate<ProgramMethod> isLiveMethod,
CfPostProcessingDesugaringEventConsumer eventConsumer,
ExecutorService executorService)
throws ExecutionException;
@@ -83,6 +86,7 @@
@Override
public void postProcessingDesugaring(
Collection<DexProgramClass> programClasses,
+ Predicate<ProgramMethod> isLiveMethod,
CfPostProcessingDesugaringEventConsumer eventConsumer,
ExecutorService executorService)
throws ExecutionException {
@@ -107,6 +111,7 @@
@Override
public void postProcessingDesugaring(
Collection<DexProgramClass> programClasses,
+ Predicate<ProgramMethod> isLiveMethod,
CfPostProcessingDesugaringEventConsumer eventConsumer,
ExecutorService executorService)
throws ExecutionException {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
index 66042a0..e4a34c4 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
@@ -30,8 +30,9 @@
return new D8CfPostProcessingDesugaringEventConsumer(methodProcessor, instructionDesugaring);
}
- public static R8PostProcessingDesugaringEventConsumer createForR8(SyntheticAdditions additions) {
- return new R8PostProcessingDesugaringEventConsumer(additions);
+ public static R8PostProcessingDesugaringEventConsumer createForR8(
+ SyntheticAdditions additions, CfInstructionDesugaringCollection desugaring) {
+ return new R8PostProcessingDesugaringEventConsumer(additions, desugaring);
}
public abstract void finalizeDesugaring() throws ExecutionException;
@@ -53,10 +54,8 @@
}
private void addMethodToReprocess(ProgramMethod method) {
- if (instructionDesugaring.needsDesugaring(method)) {
- instructionDesugaring.needsDesugaring(method);
- }
assert !instructionDesugaring.needsDesugaring(method);
+ assert method.getDefinition().getCode().isCfCode();
methodsToReprocess.add(method);
}
@@ -71,13 +70,24 @@
}
@Override
+ public void acceptEmulatedInterfaceMarkerInterface(
+ DexProgramClass clazz, DexClasspathClass newInterface) {
+ // Intentionally empty.
+ }
+
+ @Override
public void acceptForwardingMethod(ProgramMethod method) {
addMethodToReprocess(method);
}
@Override
public void acceptCompanionClassClinit(ProgramMethod method) {
- methodsToReprocess.add(method);
+ addMethodToReprocess(method);
+ }
+
+ @Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companion) {
+ // Intentionally empty. The method must be processed on the interface definition.
}
@Override
@@ -103,17 +113,27 @@
extends CfPostProcessingDesugaringEventConsumer {
private final SyntheticAdditions additions;
+ private final CfInstructionDesugaringCollection desugaring;
- R8PostProcessingDesugaringEventConsumer(SyntheticAdditions additions) {
+ R8PostProcessingDesugaringEventConsumer(
+ SyntheticAdditions additions, CfInstructionDesugaringCollection desugaring) {
this.additions = additions;
+ this.desugaring = desugaring;
}
@Override
- public void finalizeDesugaring() throws ExecutionException {
+ public void finalizeDesugaring() {
// Intentionally empty.
}
@Override
+ public void acceptEmulatedInterfaceMarkerInterface(
+ DexProgramClass clazz, DexClasspathClass newInterface) {
+ additions.injectInterface(clazz, newInterface);
+ additions.addLiveClasspathClass(newInterface);
+ }
+
+ @Override
public void acceptInterfaceInjection(DexProgramClass clazz, DexClass newInterface) {
additions.injectInterface(clazz, newInterface);
}
@@ -130,11 +150,19 @@
@Override
public void acceptCompanionClassClinit(ProgramMethod method) {
- assert false : "TODO(b/183998768): Support Interface processing in R8";
+ // Generation of this method must have been done during enqueuing.
+ assert false;
+ }
+
+ @Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companion) {
+ // Generation of this method must have been done during enqueuing.
+ assert false;
}
@Override
public void acceptAPIConversionCallback(ProgramMethod method) {
+ assert !desugaring.needsDesugaring(method);
additions.addLiveMethod(method);
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
index b23f31e..027b27c 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
@@ -10,9 +10,11 @@
import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
+import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.utils.ThrowingConsumer;
import java.util.function.Consumer;
+import java.util.function.Predicate;
public class EmptyCfInstructionDesugaringCollection extends CfInstructionDesugaringCollection {
@@ -61,7 +63,14 @@
}
@Override
- public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaring(Flavor flavor) {
+ public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringD8(
+ Flavor flavor) {
+ return null;
+ }
+
+ @Override
+ public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringR8(
+ Flavor flavor, Predicate<ProgramMethod> isLiveMethod, InterfaceProcessor processor) {
return null;
}
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 61e6828..dd815a3 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
@@ -6,6 +6,7 @@
import static com.android.tools.r8.ir.desugar.lambda.ForcefullyMovedLambdaMethodConsumer.emptyForcefullyMovedLambdaMethodConsumer;
import static com.android.tools.r8.utils.ConsumerUtils.emptyConsumer;
+import static com.android.tools.r8.utils.DesugarUtils.appendFullyQualifiedHolderToMethodName;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unimplemented;
@@ -352,17 +353,14 @@
} else {
// Otherwise we need to ensure the method can be reached publicly by virtual dispatch.
// To avoid potential conflicts on the name of the lambda method once dispatch becomes virtual
- // we add the method-holder name as suffix to the lambda-method name.
+ // we add the fully qualified method-holder name as suffix to the lambda-method name.
return new InstanceLambdaImplTarget(
appView
.dexItemFactory()
.createMethod(
implMethod.holder,
implMethod.proto,
- appView
- .dexItemFactory()
- .createString(
- implMethod.name.toString() + "$" + implMethod.holder.getName())));
+ appendFullyQualifiedHolderToMethodName(implMethod, appView.dexItemFactory())));
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
index b117828..bd9805d 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.Code;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicInstructionDesugaring;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeter;
import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
@@ -19,6 +20,7 @@
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
+import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor;
import com.android.tools.r8.ir.desugar.lambda.LambdaInstructionDesugaring;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
@@ -35,6 +37,7 @@
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
+import java.util.function.Predicate;
public class NonEmptyCfInstructionDesugaringCollection extends CfInstructionDesugaringCollection {
@@ -73,9 +76,7 @@
if (appView.options().enableTryWithResourcesDesugaring()) {
desugarings.add(new TwrInstructionDesugaring(appView));
}
- // TODO(b/183998768): Enable interface method rewriter cf to cf also in R8.
- if (appView.options().isInterfaceMethodDesugaringEnabled()
- && !appView.enableWholeProgramOptimizations()) {
+ if (appView.options().isInterfaceMethodDesugaringEnabled()) {
interfaceMethodRewriter =
new InterfaceMethodRewriter(
appView, backportedMethodRewriter, desugaredLibraryRetargeter);
@@ -83,18 +84,11 @@
} else {
interfaceMethodRewriter = null;
}
- // In R8 interface method rewriting is performed in IR, we still need to filter
- // out from API conversion methods desugared by the interface method rewriter.
- InterfaceMethodRewriter enforcedInterfaceMethodRewriter =
- interfaceMethodRewriter == null && appView.options().isInterfaceMethodDesugaringEnabled()
- ? new InterfaceMethodRewriter(
- appView, backportedMethodRewriter, desugaredLibraryRetargeter)
- : interfaceMethodRewriter;
desugaredLibraryAPIConverter =
appView.rewritePrefix.isRewriting()
? new DesugaredLibraryAPIConverter(
appView,
- enforcedInterfaceMethodRewriter,
+ interfaceMethodRewriter,
desugaredLibraryRetargeter,
backportedMethodRewriter)
: null;
@@ -102,6 +96,7 @@
desugarings.add(desugaredLibraryAPIConverter);
}
desugarings.add(new LambdaInstructionDesugaring(appView));
+ desugarings.add(new ConstantDynamicInstructionDesugaring(appView));
desugarings.add(new InvokeSpecialToSelfDesugaring(appView));
desugarings.add(new InvokeToPrivateRewriter());
desugarings.add(new StringConcatInstructionDesugaring(appView));
@@ -182,7 +177,7 @@
IntBox maxStackForInstruction = new IntBox(cfCode.getMaxStack());
List<CfInstruction> desugaredInstructions =
- ListUtils.flatMap(
+ ListUtils.flatMapSameType(
cfCode.getInstructions(),
instruction -> {
Collection<CfInstruction> replacement =
@@ -305,7 +300,7 @@
assert !alsoApplicable
|| (appliedDesugaring instanceof InterfaceMethodRewriter
&& (desugaring instanceof InvokeToPrivateRewriter
- || desugaring instanceof D8NestBasedAccessDesugaring))
+ || desugaring instanceof NestBasedAccessDesugaring))
|| (appliedDesugaring instanceof TwrInstructionDesugaring
&& desugaring instanceof InterfaceMethodRewriter)
: "Desugaring of "
@@ -330,9 +325,18 @@
}
@Override
- public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaring(Flavor flavor) {
+ public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringD8(
+ Flavor flavor) {
return interfaceMethodRewriter != null
- ? interfaceMethodRewriter.getPostProcessingDesugaring(flavor)
+ ? interfaceMethodRewriter.getPostProcessingDesugaringD8(flavor)
+ : null;
+ }
+
+ @Override
+ public InterfaceMethodProcessorFacade getInterfaceMethodPostProcessingDesugaringR8(
+ Flavor flavor, Predicate<ProgramMethod> isLiveMethod, InterfaceProcessor processor) {
+ return interfaceMethodRewriter != null
+ ? interfaceMethodRewriter.getPostProcessingDesugaringR8(flavor, isLiveMethod, processor)
: null;
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicClass.java b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicClass.java
new file mode 100644
index 0000000..bd2e603
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicClass.java
@@ -0,0 +1,275 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.constantdynamic;
+
+import static org.objectweb.asm.Opcodes.GETSTATIC;
+import static org.objectweb.asm.Opcodes.INVOKESTATIC;
+import static org.objectweb.asm.Opcodes.PUTSTATIC;
+
+import com.android.tools.r8.cf.code.CfCheckCast;
+import com.android.tools.r8.cf.code.CfConstClass;
+import com.android.tools.r8.cf.code.CfConstDynamic;
+import com.android.tools.r8.cf.code.CfConstNull;
+import com.android.tools.r8.cf.code.CfConstNumber;
+import com.android.tools.r8.cf.code.CfConstString;
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfFrame;
+import com.android.tools.r8.cf.code.CfFrame.FrameType;
+import com.android.tools.r8.cf.code.CfGoto;
+import com.android.tools.r8.cf.code.CfIf;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfLabel;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfMonitor;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.cf.code.CfStore;
+import com.android.tools.r8.cf.code.CfThrow;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.CfCode;
+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.DexMethodHandle;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldAccessFlags;
+import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.graph.MethodResolutionResult;
+import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.If;
+import com.android.tools.r8.ir.code.Monitor;
+import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.synthesis.SyntheticProgramClassBuilder;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.collections.ImmutableDeque;
+import com.android.tools.r8.utils.collections.ImmutableInt2ReferenceSortedMap;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+
+public class ConstantDynamicClass {
+ public static final String INITIALIZED_FIELD_NAME = "INITIALIZED";
+ public static final String CONST_FIELD_NAME = "CONST";
+
+ final AppView<?> appView;
+ final ConstantDynamicInstructionDesugaring desugaring;
+ private final DexType accessedFrom;
+ public ConstantDynamicReference reference;
+ public final DexField initializedValueField;
+ public final DexField constantValueField;
+ final DexMethod getConstMethod;
+
+ // Considered final but is set after due to circularity in allocation.
+ private DexProgramClass clazz = null;
+
+ public ConstantDynamicClass(
+ SyntheticProgramClassBuilder builder,
+ AppView<?> appView,
+ ConstantDynamicInstructionDesugaring desugaring,
+ ProgramMethod accessedFrom,
+ CfConstDynamic constantDynamic) {
+ DexItemFactory factory = appView.dexItemFactory();
+ this.appView = appView;
+ this.desugaring = desugaring;
+ this.accessedFrom = accessedFrom.getHolderType();
+ this.reference = constantDynamic.getReference();
+ this.constantValueField =
+ factory.createField(
+ builder.getType(), constantDynamic.getType(), factory.createString(CONST_FIELD_NAME));
+ this.initializedValueField =
+ factory.createField(
+ builder.getType(), factory.booleanType, factory.createString(INITIALIZED_FIELD_NAME));
+ this.getConstMethod =
+ factory.createMethod(
+ builder.getType(),
+ factory.createProto(constantDynamic.getType()),
+ factory.createString("get"));
+
+ synthesizeConstantDynamicClass(builder);
+ }
+
+ /*
+ Generate code following this pattern:
+
+ class CondySyntheticXXX {
+ private static boolean INITIALIZED;
+ private static <constant type> CONST;
+
+ public static get() {
+ if (!INITIALIZED) {
+ synchronized (CondySyntheticXXX.class) {
+ if (!INITIALIZED) {
+ CONST = bsm(null, "constant name", <constant type>);
+ INITIALIZED = true;
+ }
+ }
+ }
+ return value;
+ }
+ }
+
+ */
+ private void synthesizeConstantDynamicClass(SyntheticProgramClassBuilder builder) {
+ synthesizeStaticFields(builder);
+ synthesizeDirectMethods(builder);
+ }
+
+ private void synthesizeStaticFields(SyntheticProgramClassBuilder builder) {
+ builder.setStaticFields(
+ ImmutableList.of(
+ DexEncodedField.builder()
+ .setField(this.initializedValueField)
+ .setAccessFlags(FieldAccessFlags.createPrivateStaticSynthetic())
+ .setApiLevel(AndroidApiLevel.minApiLevelIfEnabledOrUnknown(appView))
+ .setD8R8Synthesized()
+ .build(),
+ DexEncodedField.builder()
+ .setField(this.constantValueField)
+ .setAccessFlags(FieldAccessFlags.createPrivateStaticSynthetic())
+ .setApiLevel(AndroidApiLevel.minApiLevelIfEnabledOrUnknown(appView))
+ .setD8R8Synthesized()
+ .build()));
+ }
+
+ private void synthesizeDirectMethods(SyntheticProgramClassBuilder builder) {
+ builder.setDirectMethods(
+ ImmutableList.of(
+ DexEncodedMethod.builder()
+ .setMethod(getConstMethod)
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setCode(generateGetterCode(builder))
+ .setD8R8Synthesized()
+ .setApiLevelForDefinition(AndroidApiLevel.S)
+ .setApiLevelForCode(AndroidApiLevel.S)
+ .build()));
+ }
+
+ private void invokeBootstrapMethod(
+ ConstantDynamicReference reference, ImmutableList.Builder<CfInstruction> instructions) {
+ assert reference.getBootstrapMethod().type.isInvokeStatic();
+
+ // TODO(b/178172809): Use MethodHandle.invokeWithArguments if supported.
+ DexMethodHandle bootstrapMethodHandle = reference.getBootstrapMethod();
+ DexMethod bootstrapMethodReference = bootstrapMethodHandle.asMethod();
+ MethodResolutionResult resolution =
+ appView
+ .appInfoForDesugaring()
+ .resolveMethod(bootstrapMethodReference, bootstrapMethodHandle.isInterface);
+ if (resolution.isFailedResolution()) {
+ // TODO(b/178172809): Generate code which throws ICCE.
+ }
+ SingleResolutionResult result = resolution.asSingleResolution();
+ assert result.getResolvedMethod().isStatic();
+ assert result.getResolvedHolder().isProgramClass();
+ instructions.add(new CfConstNull());
+ instructions.add(new CfConstString(reference.getName()));
+ instructions.add(new CfConstClass(reference.getType()));
+ instructions.add(new CfInvoke(INVOKESTATIC, bootstrapMethodReference, false));
+ instructions.add(new CfCheckCast(reference.getType()));
+
+ // Ensure that the bootstrap method is accessible from the generated class.
+ MethodAccessFlags flags = result.getResolvedMethod().getAccessFlags();
+ flags.unsetPrivate();
+ flags.setPublic();
+ }
+
+ private CfCode generateGetterCode(SyntheticProgramClassBuilder builder) {
+ int maxStack = 3;
+ int maxLocals = 2;
+ ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+ ImmutableList.Builder<CfInstruction> instructions = ImmutableList.builder();
+
+ CfLabel initializedTrue = new CfLabel();
+ CfLabel initializedTrueSecond = new CfLabel();
+ CfLabel tryCatchStart = new CfLabel();
+ CfLabel tryCatchEnd = new CfLabel();
+ CfLabel tryCatchTarget = new CfLabel();
+ CfLabel tryCatchEndFinally = new CfLabel();
+
+ instructions.add(new CfFieldInstruction(GETSTATIC, initializedValueField));
+ instructions.add(new CfIf(If.Type.NE, ValueType.INT, initializedTrue));
+
+ instructions.add(new CfConstClass(builder.getType()));
+ instructions.add(new CfStackInstruction(Opcode.Dup));
+ instructions.add(new CfStore(ValueType.OBJECT, 0));
+ instructions.add(new CfMonitor(Monitor.Type.ENTER));
+ instructions.add(tryCatchStart);
+
+ instructions.add(new CfFieldInstruction(GETSTATIC, initializedValueField));
+ instructions.add(new CfIf(If.Type.NE, ValueType.INT, initializedTrueSecond));
+
+ invokeBootstrapMethod(reference, instructions);
+ instructions.add(new CfFieldInstruction(PUTSTATIC, constantValueField));
+ instructions.add(new CfConstNumber(1, ValueType.INT));
+ instructions.add(new CfFieldInstruction(PUTSTATIC, initializedValueField));
+
+ instructions.add(initializedTrueSecond);
+ instructions.add(
+ new CfFrame(
+ ImmutableInt2ReferenceSortedMap.of(
+ new int[] {0},
+ new FrameType[] {FrameType.initialized(builder.getFactory().objectType)}),
+ ImmutableDeque.of()));
+ instructions.add(new CfLoad(ValueType.OBJECT, 0));
+ instructions.add(new CfMonitor(Monitor.Type.EXIT));
+ instructions.add(tryCatchEnd);
+ instructions.add(new CfGoto(initializedTrue));
+
+ instructions.add(tryCatchTarget);
+ instructions.add(
+ new CfFrame(
+ ImmutableInt2ReferenceSortedMap.of(
+ new int[] {0},
+ new FrameType[] {FrameType.initialized(builder.getFactory().objectType)}),
+ ImmutableDeque.of(FrameType.initialized(builder.getFactory().throwableType))));
+ instructions.add(new CfStore(ValueType.OBJECT, 1));
+ instructions.add(new CfLoad(ValueType.OBJECT, 0));
+ instructions.add(new CfMonitor(Monitor.Type.EXIT));
+ instructions.add(tryCatchEndFinally);
+ instructions.add(new CfLoad(ValueType.OBJECT, 1));
+ instructions.add(new CfThrow());
+
+ instructions.add(initializedTrue);
+ instructions.add(new CfFrame(ImmutableInt2ReferenceSortedMap.empty(), ImmutableDeque.of()));
+ instructions.add(new CfFieldInstruction(GETSTATIC, constantValueField));
+ instructions.add(new CfReturn(ValueType.OBJECT));
+
+ List<CfTryCatch> tryCatchRanges =
+ ImmutableList.of(
+ new CfTryCatch(
+ tryCatchStart,
+ tryCatchEnd,
+ ImmutableList.of(builder.getFactory().throwableType),
+ ImmutableList.of(tryCatchTarget)),
+ new CfTryCatch(
+ tryCatchTarget,
+ tryCatchEndFinally,
+ ImmutableList.of(builder.getFactory().throwableType),
+ ImmutableList.of(tryCatchTarget)));
+ return new CfCode(
+ builder.getType(),
+ maxStack,
+ maxLocals,
+ instructions.build(),
+ tryCatchRanges,
+ localVariables);
+ }
+
+ public final DexProgramClass getConstantDynamicProgramClass() {
+ assert clazz != null;
+ return clazz;
+ }
+
+ public void setClass(DexProgramClass clazz) {
+ assert this.clazz == null;
+ assert clazz != null;
+ this.clazz = clazz;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicDesugaringEventConsumer.java
new file mode 100644
index 0000000..3c0efd7
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicDesugaringEventConsumer.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.constantdynamic;
+
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface ConstantDynamicDesugaringEventConsumer {
+
+ void acceptConstantDynamicClass(ConstantDynamicClass lambdaClass, ProgramMethod context);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicInstructionDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicInstructionDesugaring.java
new file mode 100644
index 0000000..a01fdd2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicInstructionDesugaring.java
@@ -0,0 +1,129 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar.constantdynamic;
+
+import com.android.tools.r8.cf.code.CfConstDynamic;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+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.ProgramMethod;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.android.tools.r8.utils.Box;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.objectweb.asm.Opcodes;
+
+public class ConstantDynamicInstructionDesugaring implements CfInstructionDesugaring {
+
+ private final AppView<?> appView;
+ private final Map<DexType, Map<ConstantDynamicReference, ConstantDynamicClass>>
+ dynamicConstantSyntheticsPerClass = new ConcurrentHashMap<>();
+
+ public ConstantDynamicInstructionDesugaring(AppView<?> appView) {
+ this.appView = appView;
+ }
+
+ @Override
+ public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+ return instruction.isConstDynamic();
+ }
+
+ @Override
+ public Collection<CfInstruction> desugarInstruction(
+ CfInstruction instruction,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ CfInstructionDesugaringEventConsumer eventConsumer,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext,
+ DexItemFactory dexItemFactory) {
+ if (instruction.isConstDynamic()) {
+ return desugarConstDynamicInstruction(
+ instruction.asConstDynamic(),
+ freshLocalProvider,
+ localStackAllocator,
+ eventConsumer,
+ context,
+ methodProcessingContext);
+ }
+ return null;
+ }
+
+ private Collection<CfInstruction> desugarConstDynamicInstruction(
+ CfConstDynamic invoke,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ ConstantDynamicDesugaringEventConsumer eventConsumer,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext) {
+ ConstantDynamicClass constantDynamicClass =
+ ensureConstantDynamicClass(invoke, context, methodProcessingContext, eventConsumer);
+ return ImmutableList.of(
+ new CfInvoke(Opcodes.INVOKESTATIC, constantDynamicClass.getConstMethod, false));
+ }
+
+ // Creates a class corresponding to the constant dynamic symbolic reference and context.
+ // TODO(b/178172809): Move this ensure handling to the synthetic items handling and move to
+ // one class for dynamic constants for each class using dynamic constants.
+ private ConstantDynamicClass ensureConstantDynamicClass(
+ CfConstDynamic constantDynamic,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext,
+ ConstantDynamicDesugaringEventConsumer eventConsumer) {
+ Map<ConstantDynamicReference, ConstantDynamicClass> dynamicConstantSyntheticsForClass =
+ dynamicConstantSyntheticsPerClass.computeIfAbsent(
+ context.getHolderType(), (ignore) -> new HashMap<>());
+ ConstantDynamicClass result =
+ dynamicConstantSyntheticsForClass.get(constantDynamic.getReference());
+ if (result == null) {
+ synchronized (dynamicConstantSyntheticsForClass) {
+ result = dynamicConstantSyntheticsForClass.get(constantDynamic.getReference());
+ if (result == null) {
+ result =
+ createConstantDynamicClass(
+ constantDynamic, context, methodProcessingContext, eventConsumer);
+ dynamicConstantSyntheticsForClass.put(constantDynamic.getReference(), result);
+ }
+ }
+ }
+ return result;
+ }
+
+ // TODO(b/178172809): Change to use ensureFixedClass.
+ private ConstantDynamicClass createConstantDynamicClass(
+ CfConstDynamic constantDynamic,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext,
+ ConstantDynamicDesugaringEventConsumer eventConsumer) {
+ Box<ConstantDynamicClass> box = new Box<>();
+ DexProgramClass clazz =
+ appView
+ .getSyntheticItems()
+ .createClass(
+ SyntheticKind.CONST_DYNAMIC,
+ methodProcessingContext.createUniqueContext(),
+ appView,
+ builder ->
+ box.set(
+ new ConstantDynamicClass(
+ builder, appView, this, context, constantDynamic)));
+ // Immediately set the actual program class on the constant dynamic.
+ ConstantDynamicClass constantDynamicClass = box.get();
+ constantDynamicClass.setClass(clazz);
+ eventConsumer.acceptConstantDynamicClass(constantDynamicClass, context);
+ return constantDynamicClass;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java
new file mode 100644
index 0000000..da8257c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java
@@ -0,0 +1,61 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.constantdynamic;
+
+import com.android.tools.r8.graph.DexMethodHandle;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import java.util.Objects;
+
+public class ConstantDynamicReference {
+ private final DexString name;
+ private final DexType type;
+ private final DexMethodHandle bootstrapMethod;
+ private final Object[] bootstrapMethodArguments;
+
+ public ConstantDynamicReference(
+ DexString name,
+ DexType type,
+ DexMethodHandle bootstrapMethod,
+ Object[] bootstrapMethodArguments) {
+ assert bootstrapMethodArguments.length == 0;
+ this.name = name;
+ this.type = type;
+ this.bootstrapMethod = bootstrapMethod;
+ this.bootstrapMethodArguments = bootstrapMethodArguments;
+ }
+
+ public DexString getName() {
+ return name;
+ }
+
+ public DexType getType() {
+ return type;
+ }
+
+ public DexMethodHandle getBootstrapMethod() {
+ return bootstrapMethod;
+ }
+
+ public Object[] getBootstrapMethodArguments() {
+ return bootstrapMethodArguments;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (!(obj instanceof ConstantDynamicReference)) {
+ return false;
+ }
+ ConstantDynamicReference other = (ConstantDynamicReference) obj;
+ return Objects.equals(name, other.name)
+ && Objects.equals(type, other.type)
+ && Objects.equals(bootstrapMethod, other.bootstrapMethod);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(name, type, bootstrapMethod);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/ClassProcessor.java
index 90a7b35..8661587 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/ClassProcessor.java
@@ -24,16 +24,19 @@
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GenericSignature;
+import com.android.tools.r8.graph.GenericSignature.ClassTypeSignature;
import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
import com.android.tools.r8.graph.LibraryMethod;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.MethodResolutionResult;
import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.position.MethodPosition;
import com.android.tools.r8.utils.BooleanBox;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
+import com.android.tools.r8.utils.OptionalBool;
import com.android.tools.r8.utils.WorkList;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
import com.google.common.base.Equivalence.Wrapper;
@@ -50,6 +53,7 @@
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.function.Predicate;
import org.objectweb.asm.Opcodes;
/**
@@ -344,6 +348,7 @@
private final InterfaceDesugaringSyntheticHelper helper;
private final MethodSignatureEquivalence equivalence = MethodSignatureEquivalence.get();
private final boolean needsLibraryInfo;
+ private final Predicate<ProgramMethod> isLiveMethod;
// Mapping from program and classpath classes to their information summary.
private final Map<DexClass, ClassInfo> classInfo = new ConcurrentHashMap<>();
@@ -358,7 +363,11 @@
private final Map<DexProgramClass, ProgramMethodSet> newSyntheticMethods =
new ConcurrentHashMap<>();
- ClassProcessor(AppView<?> appView) {
+ // Mapping from actual program classes to the extra interfaces needed for emulated dispatch.
+ private final Map<DexProgramClass, List<ClassTypeSignature>> newExtraInterfaceSignatures =
+ new ConcurrentHashMap<>();
+
+ ClassProcessor(AppView<?> appView, Predicate<ProgramMethod> isLiveMethod) {
this.appView = appView;
this.dexItemFactory = appView.dexItemFactory();
this.helper = new InterfaceDesugaringSyntheticHelper(appView);
@@ -369,6 +378,14 @@
.desugaredLibraryConfiguration
.getRetargetCoreLibMember()
.isEmpty();
+ this.isLiveMethod = isLiveMethod;
+ }
+
+ private boolean isLiveMethod(DexClassAndMethod method) {
+ if (method.isProgramMethod()) {
+ return isLiveMethod.test(method.asProgramMethod());
+ }
+ return true;
}
private boolean needsLibraryInfo() {
@@ -396,6 +413,16 @@
clazz.addVirtualMethods(newForwardingMethods.toDefinitionSet());
newForwardingMethods.forEach(eventConsumer::acceptForwardingMethod);
});
+ newExtraInterfaceSignatures.forEach(
+ (clazz, extraInterfaceSignatures) -> {
+ if (!extraInterfaceSignatures.isEmpty()) {
+ for (ClassTypeSignature signature : extraInterfaceSignatures) {
+ eventConsumer.acceptEmulatedInterfaceMarkerInterface(
+ clazz, helper.ensureEmulatedInterfaceMarkerInterface(signature.type()));
+ }
+ clazz.addExtraInterfaces(extraInterfaceSignatures);
+ }
+ });
}
// Computes the set of method signatures that may need forwarding methods on derived classes.
@@ -533,7 +560,7 @@
}
}
});
- clazz.asProgramClass().addExtraInterfaces(extraInterfaceSignatures);
+ newExtraInterfaceSignatures.put(clazz.asProgramClass(), extraInterfaceSignatures);
}
private void collectEmulatedInterfaces(
@@ -637,7 +664,7 @@
clazz,
wrapper.get(),
target -> {
- if (!superInfo.isTargetedByForwards(target)) {
+ if (isLiveMethod(target) && !superInfo.isTargetedByForwards(target)) {
additionalForwards.add(target);
addForwardingMethod(target, clazz);
}
@@ -821,6 +848,10 @@
DexEncodedMethod desugaringForwardingMethod =
DexEncodedMethod.createDesugaringForwardingMethod(
target, clazz, forwardMethod, dexItemFactory);
+ if (!target.isProgramDefinition()
+ || target.getDefinition().isLibraryMethodOverride().isTrue()) {
+ desugaringForwardingMethod.setLibraryMethodOverride(OptionalBool.TRUE);
+ }
addSyntheticMethod(clazz.asProgramClass(), desugaringForwardingMethod);
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceDesugaringSyntheticHelper.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceDesugaringSyntheticHelper.java
index 92a64fe..9ee3606 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceDesugaringSyntheticHelper.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceDesugaringSyntheticHelper.java
@@ -17,6 +17,7 @@
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexClasspathClass;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
@@ -32,7 +33,9 @@
import com.android.tools.r8.graph.InvalidCode;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.itf.EmulatedInterfaceSynthesizerEventConsumer.ClasspathEmulatedInterfaceSynthesizerEventConsumer;
+import com.android.tools.r8.synthesis.SyntheticClassBuilder;
import com.android.tools.r8.synthesis.SyntheticMethodBuilder;
import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.InternalOptions;
@@ -41,7 +44,6 @@
import com.google.common.collect.ImmutableList;
import java.util.Map;
import java.util.Set;
-import java.util.function.Consumer;
import java.util.function.Predicate;
import org.objectweb.asm.Opcodes;
@@ -185,6 +187,17 @@
return factory.createType(interfaceTypeDescriptor);
}
+ // TODO(b/198273164): This should take the context class and not just a type.
+ DexClasspathClass ensureEmulatedInterfaceMarkerInterface(DexType type) {
+ return appView
+ .getSyntheticItems()
+ .ensureFixedClasspathClassFromType(
+ SyntheticKind.EMULATED_INTERFACE_MARKER_CLASS,
+ type,
+ appView,
+ SyntheticClassBuilder::setInterface);
+ }
+
DexClassAndMethod ensureEmulatedInterfaceMethod(
DexClassAndMethod method, ClasspathEmulatedInterfaceSynthesizerEventConsumer eventConsumer) {
DexMethod emulatedInterfaceMethod = emulateInterfaceLibraryMethod(method);
@@ -232,10 +245,10 @@
}
DexClassAndMethod ensureStaticAsMethodOfCompanionClassStub(
- DexClassAndMethod method, Consumer<ProgramMethod> companionClinitConsumer) {
+ DexClassAndMethod method, CfInstructionDesugaringEventConsumer eventConsumer) {
if (method.isProgramMethod()) {
return ensureStaticAsMethodOfProgramCompanionClassStub(
- method.asProgramMethod(), companionClinitConsumer);
+ method.asProgramMethod(), eventConsumer);
} else {
ClasspathOrLibraryClass context = method.getHolder().asClasspathOrLibraryClass();
DexMethod companionMethodReference = staticAsMethodOfCompanionClass(method);
@@ -264,15 +277,7 @@
.methodParametersWithFakeThisArguments(appView.dexItemFactory()))
.setParameterAnnotationsList(
virtual.getParameterAnnotations().withFakeThisParameter())
- // TODO(b/183998768): Once R8 desugars in the enqueuer this should set an invalid
- // code to ensure it is never used before desugared and installed.
- .setCode(
- syntheticMethod ->
- appView.enableWholeProgramOptimizations()
- ? virtual
- .getCode()
- .getCodeAsInlining(syntheticMethod, method.getReference())
- : InvalidCode.getInstance());
+ .setCode(ignored -> InvalidCode.getInstance());
},
ignored -> {});
}
@@ -297,15 +302,7 @@
.setAnnotations(definition.annotations())
// TODO(b/183998768): Should this not also be updating with a fake 'this'
.setParameterAnnotationsList(definition.getParameterAnnotations())
- // TODO(b/183998768): Once R8 desugars in the enqueuer this should set an invalid
- // code to ensure it is never used before desugared and installed.
- .setCode(
- syntheticMethod ->
- appView.enableWholeProgramOptimizations()
- ? definition
- .getCode()
- .getCodeAsInlining(syntheticMethod, method.getReference())
- : InvalidCode.getInstance());
+ .setCode(ignored -> InvalidCode.getInstance());
},
ignored -> {});
}
@@ -368,9 +365,10 @@
}
ProgramMethod ensureStaticAsMethodOfProgramCompanionClassStub(
- ProgramMethod method, Consumer<ProgramMethod> companionClinitConsumer) {
- if (!method.getDefinition().isClassInitializer() && method.getHolder().hasClassInitializer()) {
- ensureCompanionClassInitializesInterface(method.getHolder(), companionClinitConsumer);
+ ProgramMethod method, InterfaceMethodDesugaringBaseEventConsumer eventConsumer) {
+ assert !method.getDefinition().isClassInitializer();
+ if (method.getHolder().hasClassInitializer()) {
+ ensureCompanionClassInitializesInterface(method.getHolder(), eventConsumer);
}
DexMethod companionMethodReference = staticAsMethodOfCompanionClass(method);
DexEncodedMethod definition = method.getDefinition();
@@ -387,21 +385,29 @@
.setGenericSignature(definition.getGenericSignature())
.setAnnotations(definition.annotations())
.setParameterAnnotationsList(definition.getParameterAnnotations())
- // TODO(b/183998768): Once R8 desugars in the enqueuer this should set an invalid
- // code to ensure it is never used before desugared and installed.
- .setCode(
- syntheticMethod ->
- appView.enableWholeProgramOptimizations()
- ? definition
- .getCode()
- .getCodeAsInlining(syntheticMethod, method.getReference())
- : InvalidCode.getInstance());
+ .setCode(ignored -> InvalidCode.getInstance());
},
- ignored -> {});
+ companion -> eventConsumer.acceptCompanionMethod(method, companion));
+ }
+
+ public ProgramMethod ensureMethodOfProgramCompanionClassStub(
+ ProgramMethod method, InterfaceMethodDesugaringBaseEventConsumer eventConsumer) {
+ DexEncodedMethod definition = method.getDefinition();
+ assert method.getHolder().isInterface();
+ assert definition.isNonAbstractNonNativeMethod();
+ assert definition.getCode() != null;
+ assert !InvalidCode.isInvalidCode(definition.getCode());
+ if (definition.isStatic()) {
+ return ensureStaticAsMethodOfProgramCompanionClassStub(method, eventConsumer);
+ }
+ if (definition.isPrivate()) {
+ return ensurePrivateAsMethodOfProgramCompanionClassStub(method);
+ }
+ return ensureDefaultAsMethodOfProgramCompanionClassStub(method);
}
private void ensureCompanionClassInitializesInterface(
- DexProgramClass iface, Consumer<ProgramMethod> companionClinitConsumer) {
+ DexProgramClass iface, InterfaceMethodDesugaringBaseEventConsumer eventConsumer) {
assert hasStaticMethodThatTriggersNonTrivialClassInitializer(iface);
InterfaceProcessor.ensureCompanionMethod(
iface,
@@ -409,7 +415,7 @@
appView.dexItemFactory().createProto(appView.dexItemFactory().voidType),
appView,
methodBuilder -> createCompanionClassInitializer(iface, methodBuilder),
- companionClinitConsumer);
+ eventConsumer::acceptCompanionClassClinit);
}
private DexEncodedField ensureStaticClinitFieldToTriggerInterfaceInitialization(
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringBaseEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringBaseEventConsumer.java
new file mode 100644
index 0000000..4e1a30f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringBaseEventConsumer.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.itf;
+
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface InterfaceMethodDesugaringBaseEventConsumer {
+
+ void acceptCompanionClassClinit(ProgramMethod method);
+
+ void acceptCompanionMethod(ProgramMethod method, ProgramMethod companionMethod);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringEventConsumer.java
index bdc8816..9a65214 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodDesugaringEventConsumer.java
@@ -6,13 +6,10 @@
import com.android.tools.r8.graph.ProgramMethod;
-public interface InterfaceMethodDesugaringEventConsumer {
+public interface InterfaceMethodDesugaringEventConsumer
+ extends InterfaceMethodDesugaringBaseEventConsumer {
void acceptThrowMethod(ProgramMethod method, ProgramMethod context);
void acceptInvokeStaticInterfaceOutliningMethod(ProgramMethod method, ProgramMethod context);
-
- void acceptCompanionClassClinit(ProgramMethod method);
-
- // TODO(b/183998768): Add acceptCompanionClass and acceptEmulatedInterface.
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
index f989858..94a4e60 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
@@ -7,18 +7,17 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaring;
import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
import com.android.tools.r8.utils.ThreadUtils;
-import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import java.util.function.Predicate;
public class InterfaceMethodProcessorFacade implements CfPostProcessingDesugaring {
@@ -26,18 +25,30 @@
private final Flavor flavour;
private final List<InterfaceDesugaringProcessor> interfaceDesugaringProcessors;
- InterfaceMethodProcessorFacade(AppView<?> appView, Flavor flavour) {
+ InterfaceMethodProcessorFacade(
+ AppView<?> appView, Flavor flavour, Predicate<ProgramMethod> isLiveMethod) {
this.appView = appView;
this.flavour = flavour;
- interfaceDesugaringProcessors = instantiateInterfaceDesugaringProcessors(appView);
+ interfaceDesugaringProcessors = instantiateInterfaceDesugaringProcessors(appView, isLiveMethod);
+ }
+
+ InterfaceMethodProcessorFacade(
+ AppView<?> appView,
+ Flavor flavour,
+ Predicate<ProgramMethod> isLiveMethod,
+ InterfaceProcessor interfaceProcessor) {
+ this.appView = appView;
+ this.flavour = flavour;
+ interfaceDesugaringProcessors =
+ ImmutableList.of(new ClassProcessor(appView, isLiveMethod), interfaceProcessor);
}
private List<InterfaceDesugaringProcessor> instantiateInterfaceDesugaringProcessors(
- AppView<?> appView) {
+ AppView<?> appView, Predicate<ProgramMethod> isLiveMethod) {
// Process all classes first. Add missing forwarding methods to
// replace desugared default interface methods.
- ClassProcessor classProcessor = new ClassProcessor(appView);
+ ClassProcessor classProcessor = new ClassProcessor(appView, isLiveMethod);
// Process interfaces, create companion or dispatch class if needed, move static
// methods to companion class, copy default interface methods to companion classes,
@@ -49,39 +60,6 @@
return ImmutableList.of(classProcessor, interfaceProcessor);
}
- /** Runs the interfaceProcessor, the class processor and the emulated interface processor. */
- void runInterfaceDesugaringProcessorsForR8(IRConverter converter, ExecutorService executorService)
- throws ExecutionException {
-
- CollectingInterfaceDesugaringEventConsumer eventConsumer =
- new CollectingInterfaceDesugaringEventConsumer();
- processClassesConcurrently(appView.appInfo().classes(), eventConsumer, executorService);
- converter.processMethodsConcurrently(
- eventConsumer.getSortedSynthesizedMethods(), executorService);
- }
-
- // This temporary class avoids the duality between collecting with IR processing and
- // having events with the Cf desugaring.
- private static class CollectingInterfaceDesugaringEventConsumer
- implements InterfaceProcessingDesugaringEventConsumer {
-
- SortedProgramMethodSet sortedSynthesizedMethods = SortedProgramMethodSet.createConcurrent();
-
- @Override
- public void acceptForwardingMethod(ProgramMethod method) {
- sortedSynthesizedMethods.add(method);
- }
-
- @Override
- public void acceptCompanionClassClinit(ProgramMethod method) {
- sortedSynthesizedMethods.add(method);
- }
-
- public SortedProgramMethodSet getSortedSynthesizedMethods() {
- return sortedSynthesizedMethods;
- }
- }
-
private boolean shouldProcess(DexProgramClass clazz, Flavor flavour) {
if (appView.isAlreadyLibraryDesugared(clazz)) {
return false;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
index 8b3f70e..77f2c98 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
@@ -38,10 +38,8 @@
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.Invoke.Type;
import com.android.tools.r8.ir.code.InvokeMethod;
@@ -70,7 +68,6 @@
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.android.tools.r8.utils.structural.Ordered;
import com.google.common.collect.Sets;
import java.util.ArrayList;
@@ -80,11 +77,10 @@
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.function.Predicate;
//
// Default and static interface method desugaring rewriter (note that lambda
@@ -267,7 +263,9 @@
AppInfoWithClassHierarchy appInfoForDesugaring = appView.appInfoForDesugaring();
SingleResolutionResult resolution =
appInfoForDesugaring.resolveMethod(method, invokeType == INTERFACE).asSingleResolution();
- if (resolution != null && resolution.getResolvedMethod().isPrivateMethod()) {
+ if (resolution != null
+ && (resolution.getResolvedMethod().isPrivate()
+ || resolution.getResolvedMethod().isStatic())) {
return true;
}
return defaultMethodForEmulatedDispatchOrNull(method, invokeType == INTERFACE) != null;
@@ -442,10 +440,15 @@
.resolveMethod(invoke.getMethod(), invoke.isInterface())
.asSingleResolution();
if (resolution != null
- && resolution.getResolvedMethod().isPrivateMethod()
+ && resolution.getResolvedMethod().isPrivate()
&& resolution.isAccessibleFrom(context, appInfoForDesugaring).isTrue()) {
- return rewriteInvokeDirect(invoke.getMethod(), context, rewriteInvoke);
+ // TODO(b/198267586): What about the private in-accessible case?
+ return rewriteInvokeDirect(invoke.getMethod(), context, rewriteInvoke, eventConsumer);
}
+ if (resolution != null && resolution.getResolvedMethod().isStatic()) {
+ return rewriteToThrow.apply(resolution);
+ }
+ // TODO(b/198267586): What about an invoke <init>?
return rewriteInvokeInterfaceOrInvokeVirtual(
invoke.getMethod(), invoke.isInterface(), rewriteInvoke, eventConsumer);
}
@@ -465,13 +468,14 @@
staticOutliningMethodConsumer,
rewriteInvoke,
rewriteToThrow,
- eventConsumer::acceptCompanionClassClinit);
+ eventConsumer);
}
assert invoke.isInvokeSpecial();
if (invoke.isInvokeSuper(context.getHolderType())) {
- return rewriteInvokeSuper(invoke.getMethod(), context, rewriteInvoke, rewriteToThrow);
+ return rewriteInvokeSuper(
+ invoke.getMethod(), context, rewriteInvoke, rewriteToThrow, eventConsumer);
}
- return rewriteInvokeDirect(invoke.getMethod(), context, rewriteInvoke);
+ return rewriteInvokeDirect(invoke.getMethod(), context, rewriteInvoke, eventConsumer);
}
private Collection<CfInstruction> rewriteInvokeToThrowCf(
@@ -568,113 +572,6 @@
}
}
- // Rewrites the references to static and default interface methods.
- // NOTE: can be called for different methods concurrently.
- public void rewriteMethodReferences(
- IRCode code,
- MethodProcessor methodProcessor,
- MethodProcessingContext methodProcessingContext) {
- ProgramMethod context = code.context();
- if (isSyntheticMethodThatShouldNotBeDoubleProcessed(code.context())) {
- // As the synthetics for dispatching to static interface methods are not desugared again
- // this can leave a static invoke to a static method on an interface.
- leavingStaticInvokeToInterface(context.asProgramMethod());
- return;
- }
-
- Set<Value> affectedValues = Sets.newIdentityHashSet();
- Set<BasicBlock> blocksToRemove = Sets.newIdentityHashSet();
- ListIterator<BasicBlock> blocks = code.listIterator();
- while (blocks.hasNext()) {
- BasicBlock block = blocks.next();
- if (blocksToRemove.contains(block)) {
- continue;
- }
- InstructionListIterator instructions = block.listIterator(code);
- while (instructions.hasNext()) {
- Instruction instruction = instructions.next();
- rewriteMethodReferences(
- code,
- methodProcessor,
- methodProcessingContext,
- context,
- affectedValues,
- blocksToRemove,
- blocks,
- instructions,
- instruction);
- }
- }
-
- code.removeBlocks(blocksToRemove);
-
- if (!affectedValues.isEmpty()) {
- new TypeAnalysis(appView).narrowing(affectedValues);
- }
-
- assert code.isConsistentSSA();
- }
-
- private void rewriteMethodReferences(
- IRCode code,
- MethodProcessor methodProcessor,
- MethodProcessingContext methodProcessingContext,
- ProgramMethod context,
- Set<Value> affectedValues,
- Set<BasicBlock> blocksToRemove,
- ListIterator<BasicBlock> blocks,
- InstructionListIterator instructions,
- Instruction instruction) {
- if (instruction.isInvokeCustom()) {
- reportInterfaceMethodHandleCallSite(instruction.asInvokeCustom().getCallSite(), context);
- return;
- }
- if (!instruction.isInvokeMethod()) {
- return;
- }
- InvokeMethod invoke = instruction.asInvokeMethod();
- Function<DexMethod, Collection<CfInstruction>> rewriteInvoke =
- (newTarget) -> {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(newTarget, invoke.outValue(), invoke.arguments()));
- return null;
- };
- if (instruction.isInvokeDirect()) {
- rewriteInvokeDirect(invoke.getInvokedMethod(), context, rewriteInvoke);
- } else if (instruction.isInvokeVirtual() || instruction.isInvokeInterface()) {
- rewriteInvokeInterfaceOrInvokeVirtual(
- invoke.getInvokedMethod(), invoke.getInterfaceBit(), rewriteInvoke, null);
- } else {
- Function<SingleResolutionResult, Collection<CfInstruction>> rewriteToThrow =
- (resolutionResult) ->
- rewriteInvokeToThrowIR(
- invoke,
- resolutionResult,
- code,
- blocks,
- instructions,
- affectedValues,
- blocksToRemove,
- methodProcessor,
- methodProcessingContext);
- if (instruction.isInvokeStatic()) {
- // TODO(b/192439456): Make a test to prove resolution is needed here and fix it.
- rewriteInvokeStatic(
- invoke.getInvokedMethod(),
- invoke.getInterfaceBit(),
- methodProcessingContext,
- context,
- synthesizedMethods::add,
- rewriteInvoke,
- rewriteToThrow,
- synthesizedMethods::add);
- } else {
- assert instruction.isInvokeSuper();
- rewriteInvokeSuper(invoke.getInvokedMethod(), context, rewriteInvoke, rewriteToThrow);
- }
- }
- }
-
private boolean isSyntheticMethodThatShouldNotBeDoubleProcessed(ProgramMethod method) {
return appView.getSyntheticItems().isSyntheticMethodThatShouldNotBeDoubleProcessed(method);
}
@@ -693,7 +590,8 @@
private Collection<CfInstruction> rewriteInvokeDirect(
DexMethod invokedMethod,
ProgramMethod context,
- Function<DexMethod, Collection<CfInstruction>> rewriteInvoke) {
+ Function<DexMethod, Collection<CfInstruction>> rewriteInvoke,
+ InterfaceMethodDesugaringEventConsumer eventConsumer) {
if (factory.isConstructor(invokedMethod)) {
return null;
}
@@ -723,19 +621,24 @@
// method is expected to be in the current class since it is private, but desugaring
// may move some methods or their code into other classes.
assert invokeNeedsRewriting(invokedMethod, DIRECT);
+ DexClassAndMethod companionMethodDefinition = null;
DexMethod companionMethod;
if (directTarget.getDefinition().isPrivateMethod()) {
- companionMethod =
- directTarget.isProgramMethod()
- ? helper
- .ensurePrivateAsMethodOfProgramCompanionClassStub(
- directTarget.asProgramMethod())
- .getReference()
- // TODO(b/183998768): Why does this not create a stub on the class path?
- : helper.privateAsMethodOfCompanionClass(directTarget);
+ if (directTarget.isProgramMethod()) {
+ companionMethodDefinition =
+ helper.ensurePrivateAsMethodOfProgramCompanionClassStub(
+ directTarget.asProgramMethod());
+ companionMethod = companionMethodDefinition.getReference();
+ } else {
+ // TODO(b/183998768): Why does this not create a stub on the class path?
+ companionMethod = helper.privateAsMethodOfCompanionClass(directTarget);
+ }
} else {
- companionMethod =
- helper.ensureDefaultAsMethodOfCompanionClassStub(directTarget).getReference();
+ companionMethodDefinition = helper.ensureDefaultAsMethodOfCompanionClassStub(directTarget);
+ companionMethod = companionMethodDefinition.getReference();
+ }
+ if (companionMethodDefinition != null) {
+ acceptCompanionMethod(directTarget, companionMethodDefinition, eventConsumer);
}
return rewriteInvoke.apply(companionMethod);
} else {
@@ -745,8 +648,10 @@
if (virtualTarget != null) {
// This is a invoke-direct call to a virtual method.
assert invokeNeedsRewriting(invokedMethod, DIRECT);
- return rewriteInvoke.apply(
- helper.ensureDefaultAsMethodOfCompanionClassStub(virtualTarget).getReference());
+ DexClassAndMethod companionMethod =
+ helper.ensureDefaultAsMethodOfCompanionClassStub(virtualTarget);
+ acceptCompanionMethod(virtualTarget, companionMethod, eventConsumer);
+ return rewriteInvoke.apply(companionMethod.getReference());
} else {
// The below assert is here because a well-type program should have a target, but we
// cannot throw a compilation error, since we have no knowledge about the input.
@@ -756,6 +661,16 @@
return null;
}
+ private void acceptCompanionMethod(
+ DexClassAndMethod method,
+ DexClassAndMethod companion,
+ InterfaceMethodDesugaringEventConsumer eventConsumer) {
+ assert method.isProgramMethod() == companion.isProgramMethod();
+ if (method.isProgramMethod()) {
+ eventConsumer.acceptCompanionMethod(method.asProgramMethod(), companion.asProgramMethod());
+ }
+ }
+
private Collection<CfInstruction> rewriteInvokeStatic(
DexMethod invokedMethod,
boolean interfaceBit,
@@ -764,7 +679,7 @@
Consumer<ProgramMethod> staticOutliningMethodConsumer,
Function<DexMethod, Collection<CfInstruction>> rewriteInvoke,
Function<SingleResolutionResult, Collection<CfInstruction>> rewriteToThrow,
- Consumer<ProgramMethod> companionClinitConsumer) {
+ CfInstructionDesugaringEventConsumer eventConsumer) {
if (appView.getSyntheticItems().isPendingSynthetic(invokedMethod.holder)) {
// We did not create this code yet, but it will not require rewriting.
return null;
@@ -858,9 +773,9 @@
assert resolutionResult != null;
assert resolutionResult.getResolvedMethod().isStatic();
assert invokeNeedsRewriting(invokedMethod, STATIC);
+ DexClassAndMethod method = resolutionResult.getResolutionPair();
DexClassAndMethod companionMethod =
- helper.ensureStaticAsMethodOfCompanionClassStub(
- resolutionResult.getResolutionPair(), companionClinitConsumer);
+ helper.ensureStaticAsMethodOfCompanionClassStub(method, eventConsumer);
return rewriteInvoke.apply(companionMethod.getReference());
}
@@ -868,7 +783,8 @@
DexMethod invokedMethod,
ProgramMethod context,
Function<DexMethod, Collection<CfInstruction>> rewriteInvoke,
- Function<SingleResolutionResult, Collection<CfInstruction>> rewriteToThrow) {
+ Function<SingleResolutionResult, Collection<CfInstruction>> rewriteToThrow,
+ InterfaceMethodDesugaringEventConsumer eventConsumer) {
DexClass clazz = appView.definitionFor(invokedMethod.holder, context);
if (clazz == null) {
// NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
@@ -901,10 +817,27 @@
// TODO(b/145775365): This should throw IAE.
return rewriteToThrow.apply(null);
}
- return rewriteInvoke.apply(
- helper.privateAsMethodOfCompanionClass(resolutionResult.getResolutionPair()));
+ DexClassAndMethod method = resolutionResult.getResolutionPair();
+ DexMethod companionMethod;
+ if (method.isProgramMethod()) {
+ ProgramMethod companionMethodDefinition =
+ helper.ensurePrivateAsMethodOfProgramCompanionClassStub(method.asProgramMethod());
+ companionMethod = companionMethodDefinition.getReference();
+ eventConsumer.acceptCompanionMethod(method.asProgramMethod(), companionMethodDefinition);
+ } else {
+ companionMethod = helper.privateAsMethodOfCompanionClass(method);
+ }
+ return rewriteInvoke.apply(companionMethod);
} else {
+ DexClassAndMethod method = resolutionResult.getResolutionPair();
+ // TODO(b/183998768): Why do this amend routine. We have done resolution, so would that
+ // not be the correct target!? I think this is just legacy from before resolution was
+ // implemented in full.
DexMethod amendedMethod = amendDefaultMethod(context.getHolder(), invokedMethod);
+ assert method.getReference() == amendedMethod;
+ DexClassAndMethod companionMethod =
+ helper.ensureDefaultAsMethodOfCompanionClassStub(method);
+ acceptCompanionMethod(method, companionMethod, eventConsumer);
return rewriteInvoke.apply(
InterfaceDesugaringSyntheticHelper.defaultAsMethodOfCompanionClass(
amendedMethod, appView.dexItemFactory()));
@@ -920,8 +853,10 @@
DexClass holder = target.getHolder();
if (holder.isLibraryClass() && holder.isInterface()) {
assert invokeNeedsRewriting(invokedMethod, SUPER);
- return rewriteInvoke.apply(
- helper.ensureDefaultAsMethodOfCompanionClassStub(target).getReference());
+ DexClassAndMethod companionTarget =
+ helper.ensureDefaultAsMethodOfCompanionClassStub(target);
+ acceptCompanionMethod(target, companionTarget, eventConsumer);
+ return rewriteInvoke.apply(companionTarget.getReference());
}
}
}
@@ -1121,26 +1056,15 @@
return singleCandidate != null ? singleCandidate : method;
}
- public void finalizeInterfaceMethodRewritingThroughIR(
- IRConverter converter, ExecutorService executorService) throws ExecutionException {
- SortedProgramMethodSet sortedSynthesizedMethods = SortedProgramMethodSet.create();
- sortedSynthesizedMethods.addAll(synthesizedMethods);
- converter.processMethodsConcurrently(sortedSynthesizedMethods, executorService);
-
- // Cached data is not needed any more.
- this.cache.clear();
- this.synthesizedMethods.clear();
+ public InterfaceMethodProcessorFacade getPostProcessingDesugaringD8(Flavor flavour) {
+ return new InterfaceMethodProcessorFacade(appView, flavour, m -> true);
}
- public void runInterfaceDesugaringProcessorsForR8(
- IRConverter converter, Flavor flavour, ExecutorService executorService)
- throws ExecutionException {
- getPostProcessingDesugaring(flavour)
- .runInterfaceDesugaringProcessorsForR8(converter, executorService);
- }
-
- public InterfaceMethodProcessorFacade getPostProcessingDesugaring(Flavor flavour) {
- return new InterfaceMethodProcessorFacade(appView, flavour);
+ public InterfaceMethodProcessorFacade getPostProcessingDesugaringR8(
+ Flavor flavour,
+ Predicate<ProgramMethod> isLiveMethod,
+ InterfaceProcessor interfaceProcessor) {
+ return new InterfaceMethodProcessorFacade(appView, flavour, isLiveMethod, interfaceProcessor);
}
private Origin getMethodOrigin(DexMethod method) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessingDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessingDesugaringEventConsumer.java
index 8fc50d1..e16f254 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessingDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessingDesugaringEventConsumer.java
@@ -4,12 +4,18 @@
package com.android.tools.r8.ir.desugar.itf;
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ProgramMethod;
-public interface InterfaceProcessingDesugaringEventConsumer {
+// TODO(b/183998768): Consider forcing the processing of interface methods in D8 akin to R8.
+// That would avoid the need to reiterate the interface methods to collect info and this
+// could avoid the "base" methods.
+public interface InterfaceProcessingDesugaringEventConsumer
+ extends InterfaceMethodDesugaringBaseEventConsumer {
void acceptForwardingMethod(ProgramMethod method);
- // TODO(b/183998768): Remove this once interface desugaring is moved to the R8 enqueuer.
- void acceptCompanionClassClinit(ProgramMethod method);
+ void acceptEmulatedInterfaceMarkerInterface(
+ DexProgramClass clazz, DexClasspathClass newInterface);
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessor.java
index ac12741..dd4a7a9 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceProcessor.java
@@ -9,7 +9,6 @@
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.code.InvokeSuper;
import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.Code;
import com.android.tools.r8.graph.DexClass;
@@ -33,7 +32,6 @@
import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
import com.android.tools.r8.utils.collections.BidirectionalOneToOneHashMap;
import com.android.tools.r8.utils.collections.BidirectionalOneToOneMap;
-import com.android.tools.r8.utils.collections.EmptyBidirectionalOneToOneMap;
import com.android.tools.r8.utils.collections.MutableBidirectionalOneToOneMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
@@ -44,6 +42,7 @@
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
import java.util.function.Consumer;
// Default and static method interface desugaring processor for interfaces.
@@ -59,14 +58,22 @@
private final Map<DexProgramClass, PostProcessingInterfaceInfo> postProcessingInterfaceInfos =
new ConcurrentHashMap<>();
- InterfaceProcessor(AppView<?> appView) {
+ public InterfaceProcessor(AppView<?> appView) {
this.appView = appView;
helper = new InterfaceDesugaringSyntheticHelper(appView);
}
+ public InterfaceDesugaringSyntheticHelper getHelper() {
+ return helper;
+ }
+
@Override
public void process(
DexProgramClass iface, InterfaceProcessingDesugaringEventConsumer eventConsumer) {
+ if (appView.enableWholeProgramOptimizations()) {
+ // R8 populates all info as part of enqueuing.
+ return;
+ }
if (!iface.isInterface()) {
return;
}
@@ -75,9 +82,9 @@
}
private void analyzeBridges(DexProgramClass iface) {
+ assert !appView.enableWholeProgramOptimizations();
for (ProgramMethod method : iface.virtualProgramMethods()) {
- DexEncodedMethod virtual = method.getDefinition();
- if (!interfaceMethodRemovalChangesApi(virtual, iface)) {
+ if (!interfaceMethodRemovalChangesApi(method, iface)) {
getPostProcessingInterfaceInfo(iface).setHasBridgesToRemove();
return;
}
@@ -86,9 +93,6 @@
private void ensureCompanionClassMethods(
DexProgramClass iface, InterfaceProcessingDesugaringEventConsumer eventConsumer) {
- // TODO(b/183998768): Once fixed, the methods should be added for processing.
- // D8 and R8 don't need to optimize the methods since they are just moved from interfaces and
- // don't need to be re-processed.
processVirtualInterfaceMethods(iface);
processDirectInterfaceMethods(iface, eventConsumer);
}
@@ -121,96 +125,76 @@
}
private void processVirtualInterfaceMethods(DexProgramClass iface) {
+ assert !appView.enableWholeProgramOptimizations();
for (ProgramMethod method : iface.virtualProgramMethods()) {
DexEncodedMethod virtual = method.getDefinition();
if (helper.isCompatibleDefaultMethod(virtual)) {
- if (!canMoveToCompanionClass(virtual)) {
- throw new CompilationError(
- "One or more instruction is preventing default interface "
- + "method from being desugared: "
- + method.toSourceString(),
- iface.origin);
- }
- Code code = virtual.getCode();
- if (code == null) {
- throw new CompilationError(
- "Code is missing for default " + "interface method: " + method.toSourceString(),
- iface.origin);
- }
// Create a new method in a companion class to represent default method implementation.
ProgramMethod companion = helper.ensureDefaultAsMethodOfProgramCompanionClassStub(method);
- DexEncodedMethod.setDebugInfoWithFakeThisParameter(
- code, companion.getReference().getArity(), appView);
finalizeMoveToCompanionMethod(method, companion);
- getPostProcessingInterfaceInfo(iface)
- .mapDefaultMethodToCompanionMethod(virtual, companion.getDefinition());
}
}
}
private void processDirectInterfaceMethods(
DexProgramClass iface, InterfaceProcessingDesugaringEventConsumer eventConsumer) {
+ assert !appView.enableWholeProgramOptimizations();
for (ProgramMethod method : iface.directProgramMethods()) {
DexEncodedMethod definition = method.getDefinition();
- if (definition.isClassInitializer()) {
- continue;
+ if (!definition.isClassInitializer()) {
+ getPostProcessingInterfaceInfo(iface).setHasNonClinitDirectMethods();
+ ProgramMethod companion =
+ helper.ensureMethodOfProgramCompanionClassStub(method, eventConsumer);
+ finalizeMoveToCompanionMethod(method, companion);
}
- if (definition.isInstanceInitializer()) {
- assert false
- : "Unexpected interface instance initializer: "
- + method.getReference().toSourceString();
- continue;
- }
-
- getPostProcessingInterfaceInfo(iface).setHasNonClinitDirectMethods();
-
- ProgramMethod companion;
- if (isStaticMethod(definition)) {
- assert definition.isPrivate() || definition.isPublic()
- : "Static interface method "
- + method.toSourceString()
- + " is expected to "
- + "either be public or private in "
- + iface.origin;
- companion =
- helper.ensureStaticAsMethodOfProgramCompanionClassStub(
- method, eventConsumer::acceptCompanionClassClinit);
- } else {
- assert definition.isPrivate();
- Code code = definition.getCode();
- if (code == null) {
- throw new CompilationError(
- "Code is missing for private instance "
- + "interface method: "
- + method.getReference().toSourceString(),
- iface.origin);
- }
- companion = helper.ensurePrivateAsMethodOfProgramCompanionClassStub(method);
- DexEncodedMethod.setDebugInfoWithFakeThisParameter(
- code, companion.getReference().getArity(), appView);
- }
-
- finalizeMoveToCompanionMethod(method, companion);
- getPostProcessingInterfaceInfo(iface)
- .moveMethod(method.getReference(), companion.getReference());
}
}
- private void finalizeMoveToCompanionMethod(ProgramMethod method, ProgramMethod companion) {
- // TODO(b/183998768): R8 should also install an "invalid code" object until the actual code
- // moves.
- assert appView.enableWholeProgramOptimizations()
- || InvalidCode.isInvalidCode(companion.getDefinition().getCode());
+ public void finalizeMoveToCompanionMethod(ProgramMethod method, ProgramMethod companion) {
+ assert InvalidCode.isInvalidCode(companion.getDefinition().getCode());
+ if (method.getDefinition().getCode() == null) {
+ throw new CompilationError(
+ "Code is missing for private instance "
+ + "interface method: "
+ + method.getReference().toSourceString(),
+ method.getOrigin());
+ }
+ if (!canMoveToCompanionClass(method)) {
+ throw new CompilationError(
+ "One or more instruction is preventing default interface "
+ + "method from being desugared: "
+ + method.toSourceString(),
+ method.getOrigin());
+ }
DexProgramClass iface = method.getHolder();
DexEncodedMethod definition = method.getDefinition();
+ assert !definition.isInitializer();
+ assert !definition.isStatic() || definition.isPrivate() || definition.isPublic()
+ : "Static interface method "
+ + method.toSourceString()
+ + " is expected to "
+ + "either be public or private in "
+ + method.getOrigin();
+
+ if (definition.isStatic() || definition.isPrivate()) {
+ getPostProcessingInterfaceInfo(iface).setHasNonClinitDirectMethods();
+ getPostProcessingInterfaceInfo(iface)
+ .moveMethod(method.getReference(), companion.getReference());
+ } else {
+ assert helper.isCompatibleDefaultMethod(definition);
+ getPostProcessingInterfaceInfo(iface)
+ .mapDefaultMethodToCompanionMethod(method.getDefinition(), companion.getDefinition());
+ }
if (definition.hasClassFileVersion()) {
companion.getDefinition().downgradeClassFileVersion(definition.getClassFileVersion());
}
- companion
- .getDefinition()
- .setCode(
- definition.getCode().getCodeAsInlining(companion.getReference(), method.getReference()),
- appView);
+ Code code =
+ definition.getCode().getCodeAsInlining(companion.getReference(), method.getReference());
+ if (!definition.isStatic()) {
+ DexEncodedMethod.setDebugInfoWithFakeThisParameter(
+ code, companion.getReference().getArity(), appView);
+ }
+ companion.getDefinition().setCode(code, appView);
definition.setCode(InvalidCode.getInstance(), appView);
}
@@ -224,8 +208,8 @@
}
}
- private boolean canMoveToCompanionClass(DexEncodedMethod method) {
- Code code = method.getCode();
+ private static boolean canMoveToCompanionClass(ProgramMethod method) {
+ Code code = method.getDefinition().getCode();
assert code != null;
if (code.isDexCode()) {
for (Instruction insn : code.asDexCode().instructions) {
@@ -254,13 +238,9 @@
// implementation to the companion class of [iface]. This is always the case for non-bridge
// methods. Bridge methods that does not override an implementation in a super-interface must
// also be kept (such a situation can happen if the vertical class merger merges two interfaces).
- private boolean interfaceMethodRemovalChangesApi(DexEncodedMethod method, DexClass iface) {
- if (appView.enableWholeProgramOptimizations()) {
- if (appView.appInfo().withLiveness().isPinned(method.getReference())) {
- return true;
- }
- }
- if (method.accessFlags.isBridge()) {
+ private boolean interfaceMethodRemovalChangesApi(ProgramMethod method, DexClass iface) {
+ assert !appView.enableWholeProgramOptimizations();
+ if (method.getAccessFlags().isBridge()) {
if (appView.options().cfToCfDesugar) {
// TODO(b/187176895): Find the compilation causing this to not be removed.
return false;
@@ -292,27 +272,22 @@
}
}
- private boolean isStaticMethod(DexEncodedMethod method) {
- if (method.accessFlags.isNative()) {
- throw new Unimplemented("Native interface methods are not yet supported.");
- }
- return method.accessFlags.isStatic()
- && !appView.dexItemFactory().isClassConstructor(method.getReference());
- }
-
private InterfaceProcessorNestedGraphLens postProcessInterfaces() {
InterfaceProcessorNestedGraphLens.Builder graphLensBuilder =
InterfaceProcessorNestedGraphLens.builder();
postProcessingInterfaceInfos.forEach(
(iface, info) -> {
- if (info.hasNonClinitDirectMethods()) {
+ if (info.hasNonClinitDirectMethods() || appView.enableWholeProgramOptimizations()) {
clearDirectMethods(iface);
}
if (info.hasDefaultMethodsToImplementationMap()) {
info.getDefaultMethodsToImplementation()
.forEach(
(defaultMethod, companionMethod) -> {
- defaultMethod.setDefaultInterfaceMethodImplementation(companionMethod);
+ assert InvalidCode.isInvalidCode(defaultMethod.getCode());
+ assert !InvalidCode.isInvalidCode(companionMethod.getCode());
+ defaultMethod.accessFlags.setAbstract();
+ defaultMethod.removeCode();
graphLensBuilder.recordCodeMovedToCompanionClass(
defaultMethod.getReference(), companionMethod.getReference());
});
@@ -321,6 +296,8 @@
info.getMethodsToMove().forEach(graphLensBuilder::move);
}
if (info.hasBridgesToRemove()) {
+ // D8 can remove bridges at this point.
+ assert !appView.enableWholeProgramOptimizations();
removeBridges(iface);
}
});
@@ -328,12 +305,12 @@
}
private void removeBridges(DexProgramClass iface) {
+ assert !appView.enableWholeProgramOptimizations();
List<DexEncodedMethod> newVirtualMethods = new ArrayList<>();
for (ProgramMethod method : iface.virtualProgramMethods()) {
- DexEncodedMethod virtual = method.getDefinition();
// Remove bridge methods.
- if (interfaceMethodRemovalChangesApi(virtual, iface)) {
- newVirtualMethods.add(virtual);
+ if (interfaceMethodRemovalChangesApi(method, iface)) {
+ newVirtualMethods.add(method.getDefinition());
}
}
@@ -350,14 +327,11 @@
@Override
public void finalizeProcessing(InterfaceProcessingDesugaringEventConsumer eventConsumer) {
+ // TODO(b/196337368): Simplify this fix-up to be specific for the move of companion methods
+ // rather than be based on a graph lens.
InterfaceProcessorNestedGraphLens graphLens = postProcessInterfaces();
if (graphLens != null) {
- if (appView.enableWholeProgramOptimizations()) {
- appView.setGraphLens(graphLens);
- }
new InterfaceMethodRewriterFixup(appView, graphLens).run();
-
- graphLens.moveToPending();
}
}
@@ -366,6 +340,15 @@
iface, ignored -> new PostProcessingInterfaceInfo());
}
+ public void forEachMethodToMove(BiConsumer<DexMethod, DexMethod> fn) {
+ postProcessingInterfaceInfos.forEach(
+ (iface, info) -> {
+ if (info.methodsToMove != null) {
+ info.methodsToMove.forEach(fn);
+ }
+ });
+ }
+
static class PostProcessingInterfaceInfo {
private Map<DexEncodedMethod, DexEncodedMethod> defaultMethodsToImplementation;
private Map<DexMethod, DexMethod> methodsToMove;
@@ -422,14 +405,11 @@
// Specific lens which remaps invocation types to static since all rewrites performed here
// are to static companion methods.
- // TODO(b/167345026): Remove the use of this lens.
+ // TODO(b/196337368): Replace this by a desugaring lens shared for D8 and R8.
public static class InterfaceProcessorNestedGraphLens extends NestedGraphLens {
- private BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod> extraNewMethodSignatures;
- private BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod>
- pendingNewMethodSignatures;
- private BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod>
- pendingExtraNewMethodSignatures;
+ private final BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod>
+ extraNewMethodSignatures;
public InterfaceProcessorNestedGraphLens(
AppView<?> appView,
@@ -441,55 +421,12 @@
this.extraNewMethodSignatures = extraNewMethodSignatures;
}
- public void moveToPending() {
- // These are "pending" and installed in the "toggled" state only.
- pendingNewMethodSignatures = newMethodSignatures;
- pendingExtraNewMethodSignatures = extraNewMethodSignatures;
- // The interface methods do not contribute to renaming lens info anymore, so they are cleared.
- newMethodSignatures = new EmptyBidirectionalOneToOneMap<>();
- this.extraNewMethodSignatures = new EmptyBidirectionalOneToOneMap<>();
- }
-
- public static InterfaceProcessorNestedGraphLens find(GraphLens lens) {
- if (lens.isInterfaceProcessorLens()) {
- return lens.asInterfaceProcessorLens();
- }
- if (lens.isIdentityLens()) {
- return null;
- }
- if (lens.isNonIdentityLens()) {
- return find(lens.asNonIdentityLens().getPrevious());
- }
- assert false;
- return null;
- }
-
- public void enableMapping() {
- this.newMethodSignatures = pendingExtraNewMethodSignatures;
- this.extraNewMethodSignatures = pendingNewMethodSignatures;
- }
-
- public void disableMapping() {
- this.newMethodSignatures = new EmptyBidirectionalOneToOneMap<>();
- this.extraNewMethodSignatures = new EmptyBidirectionalOneToOneMap<>();
- }
-
public BidirectionalManyToManyRepresentativeMap<DexMethod, DexMethod>
getExtraNewMethodSignatures() {
return extraNewMethodSignatures;
}
@Override
- public boolean isInterfaceProcessorLens() {
- return true;
- }
-
- @Override
- public InterfaceProcessorNestedGraphLens asInterfaceProcessorLens() {
- return this;
- }
-
- @Override
public boolean isLegitimateToHaveEmptyMappings() {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriter.java
index 39a6ae1..7c26d30 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriter.java
@@ -413,7 +413,6 @@
@Override
public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
- assert !instruction.isInitClass();
if (instruction.isInvokeDynamic()) {
return needsDesugaring(instruction.asInvokeDynamic(), context);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index e58024e..ce0646d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -399,9 +399,7 @@
},
method -> {
targetsToRevisit.add(method);
- if (appView.options().testing.callSiteOptimizationInfoInspector != null) {
- appView.options().testing.callSiteOptimizationInfoInspector.accept(method);
- }
+ appView.options().testing.callSiteOptimizationInfoInspector.accept(method);
});
}
if (revisitedMethods != null) {
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 c07ad6d..dba8278 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
@@ -54,7 +54,6 @@
import com.android.tools.r8.ir.code.ValueTypeConstraint;
import com.android.tools.r8.ir.conversion.IRBuilder;
import com.android.tools.r8.ir.conversion.SourceCode;
-import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor.InterfaceProcessorNestedGraphLens;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.origin.Origin;
@@ -1315,29 +1314,12 @@
public ProgramMethodSet selectMethodsForOutlining() {
ProgramMethodSet methodsSelectedForOutlining = ProgramMethodSet.create();
assert outlineSites.isEmpty();
-
- // TODO(b/167345026): This is needed to ensure that default interface methods are mapped to
- // the corresponding companion methods that contain the code objects. This should be removed
- // once default interface methods are desugared prior to the first optimization pass.
- InterfaceProcessorNestedGraphLens interfaceProcessorLens =
- InterfaceProcessorNestedGraphLens.find(appView.graphLens());
- if (interfaceProcessorLens != null) {
- interfaceProcessorLens.enableMapping();
- }
-
for (LongLivedProgramMethodMultisetBuilder outlineMethods : candidateMethodLists) {
if (outlineMethods.size() >= appView.options().outline.threshold) {
ProgramMethodMultiset multiset = outlineMethods.build(appView);
multiset.forEachEntry((method, ignore) -> methodsSelectedForOutlining.add(method));
}
}
-
- // TODO(b/167345026): Remove once default interface methods are desugared prior to the first
- // optimization pass.
- if (interfaceProcessorLens != null) {
- interfaceProcessorLens.disableMapping();
- }
-
candidateMethodLists.clear();
return methodsSelectedForOutlining;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
index ae702f9..d0c82cb 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/ConcreteCallSiteOptimizationInfo.java
@@ -116,7 +116,7 @@
if (dynamicUpperBoundType == null) {
continue;
}
- assert appView.options().callSiteOptimizationOptions().isTypePropagationEnabled();
+ assert appView.options().callSiteOptimizationOptions().isDynamicTypePropagationEnabled();
// To avoid the full join of type lattices below, separately check if the nullability of
// arguments is improved, and if so, we can eagerly conclude that we've collected useful
// call site information for this method.
@@ -255,8 +255,6 @@
newCallSiteInfo.dynamicUpperBoundTypes.put(
argumentIndex, dynamicType.getDynamicUpperBoundType());
isTop = false;
- } else {
- newCallSiteInfo.dynamicUpperBoundTypes.put(argumentIndex, staticTypeElement);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/RecordRewritingNamingLens.java b/src/main/java/com/android/tools/r8/naming/RecordRewritingNamingLens.java
index e809317..ebada3d 100644
--- a/src/main/java/com/android/tools/r8/naming/RecordRewritingNamingLens.java
+++ b/src/main/java/com/android/tools/r8/naming/RecordRewritingNamingLens.java
@@ -83,6 +83,16 @@
}
@Override
+ public boolean hasPrefixRewritingLogic() {
+ return namingLens.hasPrefixRewritingLogic();
+ }
+
+ @Override
+ public DexString prefixRewrittenType(DexType type) {
+ return namingLens.prefixRewrittenType(type);
+ }
+
+ @Override
public String lookupPackageName(String packageName) {
return namingLens.lookupPackageName(packageName);
}
diff --git a/src/main/java/com/android/tools/r8/optimize/VisibilityBridgeRemover.java b/src/main/java/com/android/tools/r8/optimize/VisibilityBridgeRemover.java
index f073314..a990959 100644
--- a/src/main/java/com/android/tools/r8/optimize/VisibilityBridgeRemover.java
+++ b/src/main/java/com/android/tools/r8/optimize/VisibilityBridgeRemover.java
@@ -3,18 +3,22 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.optimize;
+import static com.android.tools.r8.utils.ThreadUtils.processItems;
+
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.PrunedItems;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.optimize.InvokeSingleTargetExtractor.InvokeKind;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.ForEachable;
-import com.android.tools.r8.utils.IntBox;
import com.google.common.collect.Sets;
import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
public class VisibilityBridgeRemover {
@@ -24,50 +28,14 @@
this.appView = appView;
}
- private void removeUnneededVisibilityBridgesFromClass(DexProgramClass clazz) {
- DexEncodedMethod[] newDirectMethods =
- removeUnneededVisibilityBridges(
- clazz::forEachProgramDirectMethod, clazz.getMethodCollection().numberOfDirectMethods());
- if (newDirectMethods != null) {
- clazz.setDirectMethods(newDirectMethods);
- }
- DexEncodedMethod[] newVirtualMethods =
- removeUnneededVisibilityBridges(
- clazz::forEachProgramVirtualMethod,
- clazz.getMethodCollection().numberOfVirtualMethods());
- if (newVirtualMethods != null) {
- clazz.setVirtualMethods(newVirtualMethods);
- }
- }
-
- private DexEncodedMethod[] removeUnneededVisibilityBridges(
- ForEachable<ProgramMethod> methods, int size) {
- Set<DexEncodedMethod> methodsToBeRemoved = Sets.newIdentityHashSet();
- methods.forEach(
- method -> {
- if (isUnneededVisibilityBridge(method)) {
- methodsToBeRemoved.add(method.getDefinition());
- }
- });
- if (!methodsToBeRemoved.isEmpty()) {
- DexEncodedMethod[] newMethods = new DexEncodedMethod[size - methodsToBeRemoved.size()];
- IntBox i = new IntBox(0);
- methods.forEach(
- method -> {
- if (!methodsToBeRemoved.contains(method.getDefinition())) {
- newMethods[i.getAndIncrement()] = method.getDefinition();
- }
- });
- return newMethods;
- }
- return null;
- }
-
private boolean isUnneededVisibilityBridge(ProgramMethod method) {
+ // Clean-up the predicate check.
if (appView.appInfo().isPinned(method.getReference())) {
return false;
}
DexEncodedMethod definition = method.getDefinition();
+ // TODO(b/198133259): Extend to definitions that are not defined as bridges.
+ // TODO(b/197490164): Remove if method is abstract.
if (!definition.isBridge() || definition.isAbstract()) {
return false;
}
@@ -75,33 +43,67 @@
new InvokeSingleTargetExtractor(appView.dexItemFactory());
method.registerCodeReferences(targetExtractor);
DexMethod target = targetExtractor.getTarget();
- InvokeKind kind = targetExtractor.getKind();
// javac-generated visibility forward bridge method has same descriptor (name, signature and
// return type).
- if (target != null && target.hasSameProtoAndName(method.getReference())) {
- assert !definition.isPrivate() && !definition.isInstanceInitializer();
- if (kind == InvokeKind.SUPER) {
- // This is a visibility forward, so check for the direct target.
- DexEncodedMethod targetMethod =
- appView.appInfo().unsafeResolveMethodDueToDexFormat(target).getSingleTarget();
- if (targetMethod != null && targetMethod.accessFlags.isPublic()) {
- if (Log.ENABLED) {
- Log.info(
- getClass(),
- "Removing visibility forwarding %s -> %s",
- method,
- targetMethod.getReference());
- }
- return true;
- }
- }
+ if (target == null || !target.match(method.getReference())) {
+ return false;
}
+ assert !definition.isPrivate() && !definition.isInstanceInitializer();
+ if (!isTargetingSuperMethod(method, targetExtractor.getKind(), target)) {
+ return false;
+ }
+ // This is a visibility forward, so check for the direct target.
+ DexEncodedMethod targetMethod =
+ appView.appInfo().unsafeResolveMethodDueToDexFormat(target).getSingleTarget();
+ if (targetMethod == null || !targetMethod.accessFlags.isPublic()) {
+ return false;
+ }
+ if (Log.ENABLED) {
+ Log.info(
+ getClass(),
+ "Removing visibility forwarding %s -> %s",
+ method,
+ targetMethod.getReference());
+ }
+ return true;
+ }
+
+ private boolean isTargetingSuperMethod(ProgramMethod method, InvokeKind kind, DexMethod target) {
+ if (kind == InvokeKind.SUPER) {
+ return true;
+ }
+ if (kind == InvokeKind.STATIC) {
+ return appView.appInfo().isStrictSubtypeOf(method.getHolderType(), target.holder);
+ }
+ assert false : "Unexpected invoke-kind for visibility bridge";
return false;
}
- public void run() {
- for (DexProgramClass clazz : appView.appInfo().classes()) {
- removeUnneededVisibilityBridgesFromClass(clazz);
- }
+ public void run(ExecutorService executorService) throws ExecutionException {
+ // Collect all visibility bridges to remove.
+ ConcurrentHashMap<DexProgramClass, Set<DexEncodedMethod>> visibilityBridgesToRemove =
+ new ConcurrentHashMap<>();
+ processItems(
+ appView.appInfo().classes(),
+ clazz -> {
+ Set<DexEncodedMethod> bridgesToRemoveForClass = Sets.newIdentityHashSet();
+ clazz.forEachProgramMethod(
+ method -> {
+ if (isUnneededVisibilityBridge(method)) {
+ bridgesToRemoveForClass.add(method.getDefinition());
+ }
+ });
+ if (!bridgesToRemoveForClass.isEmpty()) {
+ visibilityBridgesToRemove.put(clazz, bridgesToRemoveForClass);
+ }
+ },
+ executorService);
+ // Remove all bridges found.
+ PrunedItems.Builder builder = PrunedItems.builder();
+ visibilityBridgesToRemove.forEach(
+ (clazz, methods) -> {
+ clazz.getMethodCollection().removeMethods(methods);
+ methods.forEach(method -> builder.addRemovedMethod(method.getReference()));
+ });
}
}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagator.java
index 2173883..2761296 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagator.java
@@ -19,9 +19,11 @@
import com.android.tools.r8.optimize.argumentpropagation.codescanner.MethodState;
import com.android.tools.r8.optimize.argumentpropagation.codescanner.MethodStateCollectionByReference;
import com.android.tools.r8.optimize.argumentpropagation.codescanner.VirtualRootMethodsAnalysis;
+import com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria.ArgumentPropagatorReprocessingCriteriaCollection;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.ThreadUtils;
import com.android.tools.r8.utils.Timing;
+import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
@@ -40,6 +42,12 @@
*/
private ArgumentPropagatorCodeScanner codeScanner;
+ /**
+ * Analyzes the uses of arguments in methods to determine when reprocessing of methods will likely
+ * not lead to any additional code optimizations.
+ */
+ private ArgumentPropagatorReprocessingCriteriaCollection reprocessingCriteriaCollection;
+
public ArgumentPropagator(AppView<AppInfoWithLiveness> appView) {
assert appView.enableWholeProgramOptimizations();
assert appView.options().isOptimizing();
@@ -63,6 +71,7 @@
timing.begin("Initialize code scanner");
codeScanner = new ArgumentPropagatorCodeScanner(appView);
+ reprocessingCriteriaCollection = new ArgumentPropagatorReprocessingCriteriaCollection(appView);
ImmediateProgramSubtypingInfo immediateSubtypingInfo =
ImmediateProgramSubtypingInfo.create(appView);
@@ -80,7 +89,7 @@
// Compute the mapping from virtual methods to their root virtual method and the set of
// monomorphic virtual methods.
new VirtualRootMethodsAnalysis(appView, immediateSubtypingInfo)
- .extendVirtualRootMethods(appView.appInfo().classes(), codeScanner);
+ .extendVirtualRootMethods(classes, codeScanner);
},
executorService);
@@ -92,12 +101,14 @@
public void scan(
ProgramMethod method, IRCode code, MethodProcessor methodProcessor, Timing timing) {
if (codeScanner != null) {
- // TODO(b/190154391): Do we process synthetic methods using a OneTimeMethodProcessor
- // during the primary optimization pass?
assert methodProcessor.isPrimaryMethodProcessor();
codeScanner.scan(method, code, timing);
+
+ assert reprocessingCriteriaCollection != null;
+ reprocessingCriteriaCollection.analyzeArgumentUses(method, code);
} else {
assert !methodProcessor.isPrimaryMethodProcessor();
+ assert reprocessingCriteriaCollection == null;
}
}
@@ -117,8 +128,14 @@
throws ExecutionException {
assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
timing.begin("Argument propagator");
- populateParameterOptimizationInfo(executorService, timing);
- optimizeMethodParameters();
+ ImmediateProgramSubtypingInfo immediateSubtypingInfo =
+ ImmediateProgramSubtypingInfo.create(appView);
+ List<Set<DexProgramClass>> stronglyConnectedProgramComponents =
+ computeStronglyConnectedProgramClasses(appView, immediateSubtypingInfo);
+ populateParameterOptimizationInfo(
+ immediateSubtypingInfo, stronglyConnectedProgramComponents, executorService, timing);
+ optimizeMethodParameters(
+ immediateSubtypingInfo, stronglyConnectedProgramComponents, executorService);
enqueueMethodsForProcessing(postMethodProcessorBuilder);
timing.end();
}
@@ -127,7 +144,11 @@
* Called by {@link IRConverter} *after* the primary optimization pass to populate the parameter
* optimization info.
*/
- private void populateParameterOptimizationInfo(ExecutorService executorService, Timing timing)
+ private void populateParameterOptimizationInfo(
+ ImmediateProgramSubtypingInfo immediateSubtypingInfo,
+ List<Set<DexProgramClass>> stronglyConnectedProgramComponents,
+ ExecutorService executorService,
+ Timing timing)
throws ExecutionException {
// Unset the scanner since all code objects have been scanned at this point.
assert appView.isAllCodeProcessed();
@@ -136,22 +157,40 @@
codeScanner = null;
timing.begin("Compute optimization info");
- new ArgumentPropagatorOptimizationInfoPopulator(appView, codeScannerResult)
+ new ArgumentPropagatorOptimizationInfoPopulator(
+ appView,
+ immediateSubtypingInfo,
+ codeScannerResult,
+ reprocessingCriteriaCollection,
+ stronglyConnectedProgramComponents)
.populateOptimizationInfo(executorService, timing);
+ reprocessingCriteriaCollection = null;
timing.end();
}
/** Called by {@link IRConverter} to optimize method definitions. */
- private void optimizeMethodParameters() {
- // TODO(b/190154391): Remove parameters with constant values.
- // TODO(b/190154391): Remove unused parameters by simulating they are constant.
- // TODO(b/190154391): Strengthen the static type of parameters.
- // TODO(b/190154391): If we learn that a method returns a constant, then consider changing its
- // return type to void.
- // TODO(b/69963623): If we optimize a method to be unconditionally throwing (because it has a
- // bottom parameter), then for each caller that becomes unconditionally throwing, we could
- // also enqueue the caller's callers for reprocessing. This would propagate the throwing
- // information to all call sites.
+ private void optimizeMethodParameters(
+ ImmediateProgramSubtypingInfo immediateSubtypingInfo,
+ List<Set<DexProgramClass>> stronglyConnectedProgramComponents,
+ ExecutorService executorService)
+ throws ExecutionException {
+ Collection<ArgumentPropagatorGraphLens.Builder> partialGraphLensBuilders =
+ ThreadUtils.processItemsWithResults(
+ stronglyConnectedProgramComponents,
+ classes ->
+ new ArgumentPropagatorProgramOptimizer(appView, immediateSubtypingInfo)
+ .optimize(classes),
+ executorService);
+
+ // Merge all the partial, disjoint graph lens builders into a single graph lens.
+ ArgumentPropagatorGraphLens.Builder graphLensBuilder =
+ ArgumentPropagatorGraphLens.builder(appView);
+ partialGraphLensBuilders.forEach(graphLensBuilder::mergeDisjoint);
+
+ ArgumentPropagatorGraphLens graphLens = graphLensBuilder.build();
+ if (graphLens != null) {
+ appView.setGraphLens(graphLens);
+ }
}
/**
@@ -168,6 +207,7 @@
if (callSiteOptimizationInfo.isConcreteCallSiteOptimizationInfo()
&& !appView.appInfo().isNeverReprocessMethod(method.getReference())) {
postMethodProcessorBuilder.add(method);
+ appView.testing().callSiteOptimizationInfoInspector.accept(method);
}
});
}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java
new file mode 100644
index 0000000..0110197
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorGraphLens.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+public class ArgumentPropagatorGraphLens extends NonIdentityGraphLens {
+
+ ArgumentPropagatorGraphLens(AppView<AppInfoWithLiveness> appView) {
+ super(appView);
+ }
+
+ public static Builder builder(AppView<AppInfoWithLiveness> appView) {
+ return new Builder(appView);
+ }
+
+ @Override
+ public DexType getOriginalType(DexType type) {
+ return getPrevious().getOriginalType(type);
+ }
+
+ @Override
+ public Iterable<DexType> getOriginalTypes(DexType type) {
+ return getPrevious().getOriginalTypes(type);
+ }
+
+ @Override
+ public DexField getOriginalFieldSignature(DexField field) {
+ return getPrevious().getOriginalFieldSignature(field);
+ }
+
+ @Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ return getPrevious().getRenamedFieldSignature(originalField);
+ }
+
+ @Override
+ public DexMethod getOriginalMethodSignature(DexMethod method) {
+ return getPrevious().getOriginalMethodSignature(method);
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod, GraphLens applied) {
+ return applied != this
+ ? getPrevious().getRenamedMethodSignature(originalMethod, applied)
+ : originalMethod;
+ }
+
+ @Override
+ protected DexType internalDescribeLookupClassType(DexType previous) {
+ return previous;
+ }
+
+ @Override
+ protected FieldLookupResult internalDescribeLookupField(FieldLookupResult previous) {
+ return previous;
+ }
+
+ @Override
+ protected MethodLookupResult internalDescribeLookupMethod(
+ MethodLookupResult previous, DexMethod context) {
+ return previous;
+ }
+
+ @Override
+ protected DexMethod internalGetPreviousMethodSignature(DexMethod method) {
+ return method;
+ }
+
+ @Override
+ public boolean isContextFreeForMethods() {
+ return getPrevious().isContextFreeForMethods();
+ }
+
+ @Override
+ public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(DexMethod method) {
+ return getPrevious().lookupPrototypeChangesForMethodDefinition(method);
+ }
+
+ public static class Builder {
+
+ private final AppView<AppInfoWithLiveness> appView;
+
+ Builder(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
+
+ public ArgumentPropagatorGraphLens.Builder mergeDisjoint(
+ ArgumentPropagatorGraphLens.Builder partialGraphLensBuilder) {
+ // TODO(b/190154391): Implement.
+ return this;
+ }
+
+ public ArgumentPropagatorGraphLens build() {
+ // TODO(b/190154391): Implement.
+ return null;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
index 6d4f3b7..53876ab 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.optimize.argumentpropagation;
-import static com.android.tools.r8.optimize.argumentpropagation.utils.StronglyConnectedProgramClasses.computeStronglyConnectedProgramClasses;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -23,6 +22,8 @@
import com.android.tools.r8.optimize.argumentpropagation.propagation.InParameterFlowPropagator;
import com.android.tools.r8.optimize.argumentpropagation.propagation.InterfaceMethodArgumentPropagator;
import com.android.tools.r8.optimize.argumentpropagation.propagation.VirtualDispatchMethodArgumentPropagator;
+import com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria.ArgumentPropagatorReprocessingCriteriaCollection;
+import com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria.MethodReprocessingCriteria;
import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.ThreadUtils;
@@ -42,20 +43,22 @@
private final AppView<AppInfoWithLiveness> appView;
private final MethodStateCollectionByReference methodStates;
+ private final ArgumentPropagatorReprocessingCriteriaCollection reprocessingCriteriaCollection;
private final ImmediateProgramSubtypingInfo immediateSubtypingInfo;
- private final List<Set<DexProgramClass>> stronglyConnectedComponents;
+ private final List<Set<DexProgramClass>> stronglyConnectedProgramComponents;
ArgumentPropagatorOptimizationInfoPopulator(
- AppView<AppInfoWithLiveness> appView, MethodStateCollectionByReference methodStates) {
+ AppView<AppInfoWithLiveness> appView,
+ ImmediateProgramSubtypingInfo immediateSubtypingInfo,
+ MethodStateCollectionByReference methodStates,
+ ArgumentPropagatorReprocessingCriteriaCollection reprocessingCriteriaCollection,
+ List<Set<DexProgramClass>> stronglyConnectedProgramComponents) {
this.appView = appView;
- this.methodStates = methodStates;
-
- ImmediateProgramSubtypingInfo immediateSubtypingInfo =
- ImmediateProgramSubtypingInfo.create(appView);
this.immediateSubtypingInfo = immediateSubtypingInfo;
- this.stronglyConnectedComponents =
- computeStronglyConnectedProgramClasses(appView, immediateSubtypingInfo);
+ this.methodStates = methodStates;
+ this.reprocessingCriteriaCollection = reprocessingCriteriaCollection;
+ this.stronglyConnectedProgramComponents = stronglyConnectedProgramComponents;
}
/**
@@ -74,7 +77,9 @@
// that the method returns the constant.
timing.begin("Propagate argument information for virtual methods");
ThreadUtils.processItems(
- stronglyConnectedComponents, this::processStronglyConnectedComponent, executorService);
+ stronglyConnectedProgramComponents,
+ this::processStronglyConnectedComponent,
+ executorService);
timing.end();
// Solve the parameter flow constraints.
@@ -190,6 +195,14 @@
return true;
});
+ // If we have any reprocessing criteria for the given method, check that they are satisfied
+ // before reenqueing.
+ MethodReprocessingCriteria reprocessingCriteria =
+ reprocessingCriteriaCollection.getReprocessingCriteria(method);
+ if (!reprocessingCriteria.shouldReprocess(appView, method, monomorphicMethodState)) {
+ return;
+ }
+
method
.getDefinition()
.joinCallSiteOptimizationInfo(
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
new file mode 100644
index 0000000..859830b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Set;
+
+public class ArgumentPropagatorProgramOptimizer {
+
+ private final AppView<AppInfoWithLiveness> appView;
+ private final ImmediateProgramSubtypingInfo immediateSubtypingInfo;
+
+ public ArgumentPropagatorProgramOptimizer(
+ AppView<AppInfoWithLiveness> appView, ImmediateProgramSubtypingInfo immediateSubtypingInfo) {
+ this.appView = appView;
+ this.immediateSubtypingInfo = immediateSubtypingInfo;
+ }
+
+ // TODO(b/190154391): Remove parameters with constant values.
+ // TODO(b/190154391): Remove unused parameters by simulating they are constant.
+ // TODO(b/190154391): Strengthen the static type of parameters.
+ // TODO(b/190154391): If we learn that a method returns a constant, then consider changing its
+ // return type to void.
+ // TODO(b/69963623): If we optimize a method to be unconditionally throwing (because it has a
+ // bottom parameter), then for each caller that becomes unconditionally throwing, we could
+ // also enqueue the caller's callers for reprocessing. This would propagate the throwing
+ // information to all call sites.
+ public ArgumentPropagatorGraphLens.Builder optimize(
+ Set<DexProgramClass> stronglyConnectedProgramClasses) {
+ return ArgumentPropagatorGraphLens.builder(appView);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
index 6dc6c5c..3244db4 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
@@ -51,6 +51,10 @@
return this;
}
+ public AbstractValue getAbstractValue() {
+ return abstractValue;
+ }
+
@Override
public AbstractValue getAbstractValue(AppView<AppInfoWithLiveness> appView) {
return abstractValue;
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysFalseParameterReprocessingCriteria.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysFalseParameterReprocessingCriteria.java
new file mode 100644
index 0000000..90d7e4a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysFalseParameterReprocessingCriteria.java
@@ -0,0 +1,56 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteParameterState;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/**
+ * Represents that a parameter should never be reprocessed even if we have non-trivial information
+ * about it (e.g., abstract value, dynamic type, nullability).
+ *
+ * <p>Example: This is used for unused parameters.
+ */
+public class AlwaysFalseParameterReprocessingCriteria extends ParameterReprocessingCriteria {
+
+ public static final AlwaysFalseParameterReprocessingCriteria INSTANCE =
+ new AlwaysFalseParameterReprocessingCriteria();
+
+ private AlwaysFalseParameterReprocessingCriteria() {}
+
+ public static AlwaysFalseParameterReprocessingCriteria get() {
+ return INSTANCE;
+ }
+
+ @Override
+ public boolean isNeverReprocess() {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcreteParameterState parameterState,
+ DexType parameterType) {
+ return false;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToAbstractValue() {
+ return false;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToDynamicType() {
+ return false;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToNullability() {
+ return false;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysTrueParameterReprocessingCriteria.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysTrueParameterReprocessingCriteria.java
new file mode 100644
index 0000000..72d382f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/AlwaysTrueParameterReprocessingCriteria.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteParameterState;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/**
+ * Represents that a parameter should always be reprocessed if we have non-trivial information about
+ * it (e.g., abstract value, dynamic type, nullability).
+ */
+public class AlwaysTrueParameterReprocessingCriteria extends ParameterReprocessingCriteria {
+
+ public static final AlwaysTrueParameterReprocessingCriteria INSTANCE =
+ new AlwaysTrueParameterReprocessingCriteria();
+
+ private AlwaysTrueParameterReprocessingCriteria() {}
+
+ public static AlwaysTrueParameterReprocessingCriteria get() {
+ return INSTANCE;
+ }
+
+ @Override
+ public boolean isAlwaysReprocess() {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcreteParameterState parameterState,
+ DexType parameterType) {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToAbstractValue() {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToDynamicType() {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToNullability() {
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ArgumentPropagatorReprocessingCriteriaCollection.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ArgumentPropagatorReprocessingCriteriaCollection.java
new file mode 100644
index 0000000..301738e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ArgumentPropagatorReprocessingCriteriaCollection.java
@@ -0,0 +1,142 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import static com.android.tools.r8.ir.code.Opcodes.ASSUME;
+import static com.android.tools.r8.ir.code.Opcodes.IF;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_GET;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_PUT;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_DIRECT;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_INTERFACE;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_STATIC;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_SUPER;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_VIRTUAL;
+import static com.android.tools.r8.ir.code.Opcodes.RETURN;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.Argument;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InstructionIterator;
+import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ArgumentPropagatorReprocessingCriteriaCollection {
+
+ private final AppView<AppInfoWithLiveness> appView;
+
+ private final Map<DexMethod, MethodReprocessingCriteria> reproccessingCriteria =
+ new ConcurrentHashMap<>();
+
+ public ArgumentPropagatorReprocessingCriteriaCollection(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
+
+ public MethodReprocessingCriteria getReprocessingCriteria(ProgramMethod method) {
+ return reproccessingCriteria.getOrDefault(
+ method.getReference(), MethodReprocessingCriteria.empty());
+ }
+
+ /**
+ * Analyzes the uses of the method arguments to determine if a given piece of optimization info
+ * related to the arguments should or should not lead to reprocessing of the given method.
+ */
+ public void analyzeArgumentUses(ProgramMethod method, IRCode code) {
+ Int2ReferenceMap<ParameterReprocessingCriteria> methodReprocessingCriteria =
+ new Int2ReferenceOpenHashMap<>();
+
+ // Analyze each of the Argument instructions.
+ InstructionIterator instructionIterator = code.entryBlock().iterator();
+ for (Argument argument = instructionIterator.next().asArgument();
+ argument != null;
+ argument = instructionIterator.next().asArgument()) {
+ ParameterReprocessingCriteria reprocessingCriteria = analyzeArgumentUses(argument);
+ if (!reprocessingCriteria.isAlwaysReprocess()) {
+ methodReprocessingCriteria.put(argument.getIndex(), reprocessingCriteria);
+ }
+ }
+
+ // If there are some parameters which should not be naively reprocessed if they hold non-trivial
+ // optimization info, then record this information. If the map is empty, then the method should
+ // always be reprocessed if we find non-trivial optimization info for some of the parameters.
+ if (!methodReprocessingCriteria.isEmpty()) {
+ reproccessingCriteria.put(
+ method.getReference(), new MethodReprocessingCriteria(methodReprocessingCriteria));
+ }
+ }
+
+ private ParameterReprocessingCriteria analyzeArgumentUses(Argument argument) {
+ // For now, always reprocess if we have non-trivial information about primitive types.
+ // TODO(b/190154391): Introduce analysis for primitives.
+ if (argument.getOutType().isPrimitiveType()) {
+ return ParameterReprocessingCriteria.alwaysReprocess();
+ }
+
+ ParameterReprocessingCriteria.Builder builder = ParameterReprocessingCriteria.builder();
+ for (Instruction instruction : argument.outValue().aliasedUsers()) {
+ // TODO(b/190154391): Introduce analysis for usefulness of abstract value and nullability.
+ builder.setReprocessDueToAbstractValue().setReprocessDueToNullability();
+
+ switch (instruction.opcode()) {
+ case ASSUME:
+ case IF:
+ case INSTANCE_GET:
+ case INSTANCE_PUT:
+ case RETURN:
+ break;
+
+ case INVOKE_DIRECT:
+ case INVOKE_STATIC:
+ // Do not reprocess calls without dynamic dispatch due to dynamic type information.
+ break;
+
+ case INVOKE_INTERFACE:
+ case INVOKE_SUPER:
+ case INVOKE_VIRTUAL:
+ {
+ InvokeMethodWithReceiver invoke = instruction.asInvokeMethodWithReceiver();
+
+ // Do not reprocess calls with dynamic dispatch due to dynamic type information of a
+ // non-receiver operand.
+ if (invoke.getReceiver().getAliasedValue() != argument.outValue()) {
+ break;
+ }
+
+ // Do not reprocess the method if the invoke resolves to a library method.
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .unsafeResolveMethodDueToDexFormat(invoke.getInvokedMethod())
+ .asSingleResolution();
+ if (resolutionResult == null
+ || !resolutionResult.getResolvedHolder().isProgramClass()) {
+ break;
+ }
+
+ builder.setReprocessDueToDynamicType();
+ break;
+ }
+
+ default:
+ // Conservatively reprocess the method if we have a non-trivial dynamic type.
+ builder.setReprocessDueToDynamicType();
+ break;
+ }
+
+ if (builder.shouldAlwaysReprocess()) {
+ break;
+ }
+ }
+
+ return builder.build();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/MethodReprocessingCriteria.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/MethodReprocessingCriteria.java
new file mode 100644
index 0000000..527ee9e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/MethodReprocessingCriteria.java
@@ -0,0 +1,62 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteMonomorphicMethodState;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ParameterState;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
+
+public class MethodReprocessingCriteria {
+
+ public static final MethodReprocessingCriteria EMPTY = new MethodReprocessingCriteria();
+
+ private final Int2ReferenceMap<ParameterReprocessingCriteria> reproccesingCriteria;
+
+ private MethodReprocessingCriteria() {
+ this.reproccesingCriteria = new Int2ReferenceOpenHashMap<>();
+ }
+
+ public MethodReprocessingCriteria(
+ Int2ReferenceMap<ParameterReprocessingCriteria> reproccesingCriteria) {
+ assert !reproccesingCriteria.isEmpty();
+ this.reproccesingCriteria = reproccesingCriteria;
+ }
+
+ public static MethodReprocessingCriteria empty() {
+ return EMPTY;
+ }
+
+ public ParameterReprocessingCriteria getParameterReprocessingCriteria(int parameterIndex) {
+ return reproccesingCriteria.getOrDefault(
+ parameterIndex, ParameterReprocessingCriteria.alwaysReprocess());
+ }
+
+ public boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ProgramMethod method,
+ ConcreteMonomorphicMethodState methodState) {
+ for (int parameterIndex = 0; parameterIndex < methodState.size(); parameterIndex++) {
+ ParameterState parameterState = methodState.getParameterState(parameterIndex);
+ assert !parameterState.isBottom();
+ if (parameterState.isUnknown()) {
+ continue;
+ }
+
+ ParameterReprocessingCriteria parameterReprocessingCriteria =
+ getParameterReprocessingCriteria(parameterIndex);
+ DexType parameterType = method.getArgumentType(parameterIndex);
+ if (parameterReprocessingCriteria.shouldReprocess(
+ appView, parameterState.asConcrete(), parameterType)) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/NonTrivialParameterReprocessingCriteria.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/NonTrivialParameterReprocessingCriteria.java
new file mode 100644
index 0000000..b55bf13
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/NonTrivialParameterReprocessingCriteria.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.type.DynamicType;
+import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteParameterState;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcretePrimitiveTypeParameterState;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteReferenceTypeParameterState;
+import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/**
+ * Represents that a parameter should be reprocessed under certain conditions if we have non-trivial
+ * information about it (e.g., abstract value, dynamic type, nullability).
+ *
+ * <p>Example: If we determine that a parameter should not be reprocessed if we only have
+ * non-trivial information about its dynamic type, then an instance of this class is used which
+ * returns false in {@link #shouldReprocessDueToDynamicType()}.
+ */
+public class NonTrivialParameterReprocessingCriteria extends ParameterReprocessingCriteria {
+
+ public NonTrivialParameterReprocessingCriteria(boolean reprocessDueToDynamicType) {
+ assert !reprocessDueToDynamicType;
+ }
+
+ @Override
+ public boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcreteParameterState parameterState,
+ DexType parameterType) {
+ if (parameterState.isReferenceParameter()) {
+ return shouldReprocess(appView, parameterState.asReferenceParameter(), parameterType);
+ } else {
+ assert parameterState.isPrimitiveParameter();
+ return shouldReprocess(appView, parameterState.asPrimitiveParameter(), parameterType);
+ }
+ }
+
+ @Override
+ public boolean shouldReprocessDueToAbstractValue() {
+ return true;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToDynamicType() {
+ return false;
+ }
+
+ @Override
+ public boolean shouldReprocessDueToNullability() {
+ return true;
+ }
+
+ private boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcretePrimitiveTypeParameterState parameterState,
+ DexType parameterType) {
+ return true;
+ }
+
+ private boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcreteReferenceTypeParameterState parameterState,
+ DexType parameterType) {
+ if (shouldReprocessDueToAbstractValue()
+ && !parameterState.getAbstractValue(appView).isUnknown()) {
+ return true;
+ }
+ if (shouldReprocessDueToDynamicType()) {
+ DynamicType widenedDynamicType =
+ WideningUtils.widenDynamicNonReceiverType(
+ appView,
+ parameterState.getDynamicType().withNullability(Nullability.maybeNull()),
+ parameterType);
+ if (!widenedDynamicType.isUnknown()) {
+ return true;
+ }
+ }
+ if (shouldReprocessDueToNullability()
+ && !parameterState.isReceiverParameter()
+ && !parameterState.getNullability().isUnknown()) {
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ParameterReprocessingCriteria.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ParameterReprocessingCriteria.java
new file mode 100644
index 0000000..9022f81
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/reprocessingcriteria/ParameterReprocessingCriteria.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteParameterState;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+public abstract class ParameterReprocessingCriteria {
+
+ public static AlwaysTrueParameterReprocessingCriteria alwaysReprocess() {
+ return AlwaysTrueParameterReprocessingCriteria.get();
+ }
+
+ public static AlwaysFalseParameterReprocessingCriteria neverReprocess() {
+ return AlwaysFalseParameterReprocessingCriteria.get();
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public boolean isAlwaysReprocess() {
+ return false;
+ }
+
+ public boolean isNeverReprocess() {
+ return false;
+ }
+
+ public abstract boolean shouldReprocess(
+ AppView<AppInfoWithLiveness> appView,
+ ConcreteParameterState parameterState,
+ DexType parameterType);
+
+ public abstract boolean shouldReprocessDueToAbstractValue();
+
+ public abstract boolean shouldReprocessDueToDynamicType();
+
+ public abstract boolean shouldReprocessDueToNullability();
+
+ public static class Builder {
+
+ private boolean reprocessDueToAbstractValue;
+ private boolean reprocessDueToDynamicType;
+ private boolean reprocessDueToNullability;
+
+ Builder setReprocessDueToAbstractValue() {
+ reprocessDueToAbstractValue = true;
+ return this;
+ }
+
+ Builder setReprocessDueToDynamicType() {
+ reprocessDueToDynamicType = true;
+ return this;
+ }
+
+ Builder setReprocessDueToNullability() {
+ reprocessDueToNullability = true;
+ return this;
+ }
+
+ boolean shouldAlwaysReprocess() {
+ return reprocessDueToAbstractValue && reprocessDueToDynamicType && reprocessDueToNullability;
+ }
+
+ boolean shouldNeverReprocess() {
+ return !reprocessDueToAbstractValue
+ && !reprocessDueToDynamicType
+ && !reprocessDueToNullability;
+ }
+
+ public ParameterReprocessingCriteria build() {
+ if (shouldAlwaysReprocess()) {
+ return alwaysReprocess();
+ }
+ if (shouldNeverReprocess()) {
+ return neverReprocess();
+ }
+ return new NonTrivialParameterReprocessingCriteria(reprocessDueToDynamicType);
+ }
+ }
+}
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 be31b16..acc8410 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -1048,6 +1048,10 @@
keepInfo.mutate(
keepInfo -> keepInfo.removeKeepInfoForPrunedItems(prunedItems.getRemovedClasses()));
}
+ if (!prunedItems.getRemovedMethods().isEmpty()) {
+ keepInfo.mutate(
+ keepInfo -> keepInfo.removeKeepInfoForPrunedItems(prunedItems.getRemovedMethods()));
+ }
return new AppInfoWithLiveness(this, prunedItems);
}
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 41eb11b..66e9136 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -6,6 +6,7 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.graph.FieldAccessInfoImpl.MISSING_FIELD_ACCESS_INFO;
import static com.android.tools.r8.ir.desugar.LambdaDescriptor.isLambdaMetafactoryMethod;
+import static com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor.ExcludeDexResources;
import static com.android.tools.r8.naming.IdentifierNameStringUtils.identifyIdentifier;
import static com.android.tools.r8.naming.IdentifierNameStringUtils.isReflectionMethod;
import static com.android.tools.r8.utils.FunctionUtils.ignoreArgument;
@@ -59,6 +60,7 @@
import com.android.tools.r8.graph.FieldResolutionResult;
import com.android.tools.r8.graph.GenericSignatureEnqueuerAnalysis;
import com.android.tools.r8.graph.InnerClassAttribute;
+import com.android.tools.r8.graph.InvalidCode;
import com.android.tools.r8.graph.LookupLambdaTarget;
import com.android.tools.r8.graph.LookupTarget;
import com.android.tools.r8.graph.MethodAccessInfoCollection;
@@ -98,7 +100,10 @@
import com.android.tools.r8.ir.desugar.LambdaClass;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.ir.desugar.ProgramAdditions;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicClass;
import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
+import com.android.tools.r8.ir.desugar.itf.InterfaceProcessor;
import com.android.tools.r8.kotlin.KotlinMetadataEnqueuerExtension;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.naming.identifiernamestring.IdentifierNameStringLookupResult;
@@ -120,6 +125,7 @@
import com.android.tools.r8.shaking.ScopedDexMethodSet.AddMethodIfMoreVisibleResult;
import com.android.tools.r8.synthesis.SyntheticItems.SynthesizingContextOracle;
import com.android.tools.r8.utils.Action;
+import com.android.tools.r8.utils.BooleanBox;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.OptionalBool;
@@ -131,10 +137,10 @@
import com.android.tools.r8.utils.Visibility;
import com.android.tools.r8.utils.WorkList;
import com.android.tools.r8.utils.collections.ProgramFieldSet;
+import com.android.tools.r8.utils.collections.ProgramMethodMap;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
@@ -423,7 +429,20 @@
private final GraphReporter graphReporter;
private final CfInstructionDesugaringCollection desugaring;
- private final ProgramMethodSet pendingDesugaring = ProgramMethodSet.create();
+ private final ProgramMethodSet pendingCodeDesugaring = ProgramMethodSet.create();
+
+ // Collections for tracing progress on interface method desugaring.
+
+ // The pending method move set is all the methods that need to be moved to companions.
+ // They may or may not need desugaring.
+ private final ProgramMethodSet pendingMethodMove = ProgramMethodSet.create();
+
+ // The inverse map records references to companion methods that may now be active but yet to
+ // be moved.
+ private final ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse =
+ ProgramMethodMap.createConcurrent();
+
+ private final InterfaceProcessor interfaceProcessor;
Enqueuer(
AppView<? extends AppInfoWithClassHierarchy> appView,
@@ -466,10 +485,13 @@
failedFieldResolutionTargets = SetUtils.newIdentityHashSet(0);
liveMethods = new LiveMethodsSet(graphReporter::registerMethod);
liveFields = new LiveFieldsSet(graphReporter::registerField);
- desugaring =
- mode.isInitialTreeShaking()
- ? CfInstructionDesugaringCollection.create(appView)
- : CfInstructionDesugaringCollection.empty();
+ if (mode.isInitialTreeShaking()) {
+ desugaring = CfInstructionDesugaringCollection.create(appView);
+ interfaceProcessor = new InterfaceProcessor(appView);
+ } else {
+ desugaring = CfInstructionDesugaringCollection.empty();
+ interfaceProcessor = null;
+ }
objectAllocationInfoCollection =
ObjectAllocationInfoCollectionImpl.builder(mode.isInitialTreeShaking(), graphReporter);
@@ -3080,6 +3102,7 @@
public EnqueuerResult traceApplication(
RootSet rootSet, ExecutorService executorService, Timing timing) throws ExecutionException {
this.rootSet = rootSet;
+ rootSet.pendingMethodMoveInverse.forEach(pendingMethodMoveInverse::put);
// Translate the result of root-set computation into enqueuer actions.
if (mode.isTreeShaking()
&& appView.options().hasProguardConfiguration()
@@ -3324,6 +3347,8 @@
private final Map<DexMethod, ProgramMethod> liveMethods = new ConcurrentHashMap<>();
+ private final ProgramMethodSet neverInlineMethods = ProgramMethodSet.createConcurrent();
+
private final Map<DexType, DexClasspathClass> syntheticClasspathClasses =
new ConcurrentHashMap<>();
@@ -3355,7 +3380,7 @@
public void addLiveClasspathClass(DexClasspathClass clazz) {
DexClasspathClass old = syntheticClasspathClasses.put(clazz.type, clazz);
- assert old == null;
+ assert old == null || old == clazz;
}
public void addLiveMethods(Iterable<ProgramMethod> methods) {
@@ -3364,8 +3389,12 @@
public void addLiveMethod(ProgramMethod method) {
DexMethod signature = method.getDefinition().getReference();
- assert !liveMethods.containsKey(signature);
- liveMethods.put(signature, method);
+ ProgramMethod old = liveMethods.put(signature, method);
+ assert old == null;
+ }
+
+ public void addMethodWithDesugaredCodeForTracing(ProgramMethod method) {
+ desugaredMethods.add(method);
}
public void injectInterface(DexProgramClass clazz, DexClass newInterface) {
@@ -3386,6 +3415,10 @@
return set;
}
+ public void addNeverInlineMethod(ProgramMethod method) {
+ neverInlineMethods.add(method);
+ }
+
void enqueueWorkItems(Enqueuer enqueuer) {
assert enqueuer.mode.isInitialTreeShaking();
@@ -3409,6 +3442,8 @@
enqueuer.objectAllocationInfoCollection.injectInterfaces(
enqueuer.appInfo(), clazz, itfs);
});
+
+ neverInlineMethods.forEach(m -> enqueuer.rootSet.neverInline.add(m.getReference()));
}
}
@@ -3436,31 +3471,95 @@
additions.enqueueWorkItems(this);
}
+ private boolean mustMoveToInterfaceCompanionMethod(ProgramMethod method) {
+ return method.getHolder().isInterface()
+ && method.getDefinition().isNonAbstractNonNativeMethod()
+ && !method.getDefinition().isInitializer();
+ }
+
+ private boolean addToPendingDesugaring(ProgramMethod method) {
+ if (options.isInterfaceMethodDesugaringEnabled()) {
+ if (mustMoveToInterfaceCompanionMethod(method)) {
+ pendingMethodMove.add(method);
+ return true;
+ }
+ ProgramMethod nonMovedMethod = pendingMethodMoveInverse.get(method);
+ if (nonMovedMethod != null) {
+ // Any non-moved code must be a proper pending item.
+ assert InvalidCode.isInvalidCode(method.getDefinition().getCode());
+ assert !InvalidCode.isInvalidCode(nonMovedMethod.getDefinition().getCode());
+ pendingMethodMove.add(nonMovedMethod);
+ return true;
+ }
+ }
+ if (desugaring.needsDesugaring(method)) {
+ pendingCodeDesugaring.add(method);
+ return true;
+ }
+ return false;
+ }
+
private void desugar(SyntheticAdditions additions) throws ExecutionException {
- if (pendingDesugaring.isEmpty()) {
+ if (pendingCodeDesugaring.isEmpty() && pendingMethodMove.isEmpty()) {
return;
}
+ // All non-moving methods are ready for tracing post desugar.
+ pendingCodeDesugaring.forEach(additions::addMethodWithDesugaredCodeForTracing);
+ // Then amend the desugar set with the move methods that need desugaring.
+ for (ProgramMethod method : pendingMethodMove) {
+ if (desugaring.needsDesugaring(method)) {
+ pendingCodeDesugaring.add(method);
+ }
+ }
+
+ R8CfInstructionDesugaringEventConsumer eventConsumer =
+ CfInstructionDesugaringEventConsumer.createForR8(
+ appView,
+ this::recordLambdaSynthesizingContext,
+ this::recordConstantDynamicSynthesizingContext,
+ this::recordTwrCloseResourceMethodSynthesizingContext,
+ additions,
+ (method, companion) -> {
+ if (!isMethodLive(method)) {
+ // Record the original placement of the companion method such that we can desugar
+ // and transfer the code if and when the companion method becomes live.
+ pendingMethodMoveInverse.put(companion, method);
+ }
+ });
+
// Prepare desugaring by collecting all the synthetic methods required on program classes.
ProgramAdditions programAdditions = new ProgramAdditions();
ThreadUtils.processItems(
- pendingDesugaring, method -> desugaring.prepare(method, programAdditions), executorService);
+ pendingCodeDesugaring,
+ method -> desugaring.prepare(method, programAdditions),
+ executorService);
programAdditions.apply(executorService);
- R8CfInstructionDesugaringEventConsumer desugaringEventConsumer =
- CfInstructionDesugaringEventConsumer.createForR8(
- appView,
- this::recordLambdaSynthesizingContext,
- this::recordTwrCloseResourceMethodSynthesizingContext,
- additions);
+ // Then do the actual desugaring.
ThreadUtils.processItems(
- pendingDesugaring,
- method ->
- desugaring.desugar(method, additions.getMethodContext(method), desugaringEventConsumer),
+ pendingCodeDesugaring,
+ method -> desugaring.desugar(method, additions.getMethodContext(method), eventConsumer),
executorService);
- desugaringEventConsumer.finalizeDesugaring();
- Iterables.addAll(additions.desugaredMethods, pendingDesugaring);
- pendingDesugaring.clear();
+
+ // Move the pending methods and mark them live and ready for tracing.
+ for (ProgramMethod method : pendingMethodMove) {
+ ProgramMethod companion =
+ interfaceProcessor
+ .getHelper()
+ .ensureMethodOfProgramCompanionClassStub(method, eventConsumer);
+ interfaceProcessor.finalizeMoveToCompanionMethod(method, companion);
+ pendingMethodMoveInverse.remove(companion);
+ if (!isMethodLive(companion)) {
+ additions.addLiveMethod(companion);
+ }
+ additions.addMethodWithDesugaredCodeForTracing(companion);
+ }
+
+ eventConsumer.finalizeDesugaring();
+
+ pendingMethodMove.clear();
+ pendingCodeDesugaring.clear();
}
private void recordLambdaSynthesizingContext(LambdaClass lambdaClass, ProgramMethod context) {
@@ -3469,6 +3568,13 @@
}
}
+ private void recordConstantDynamicSynthesizingContext(
+ ConstantDynamicClass constantDynamicClass, ProgramMethod context) {
+ synchronized (synthesizingContexts) {
+ synthesizingContexts.put(constantDynamicClass.getConstantDynamicProgramClass(), context);
+ }
+ }
+
private void recordTwrCloseResourceMethodSynthesizingContext(
ProgramMethod closeMethod, ProgramMethod context) {
synchronized (synthesizingContexts) {
@@ -3481,8 +3587,6 @@
DexProgramClass holder = bridge.getHolder();
DexEncodedMethod method = bridge.getDefinition();
holder.addVirtualMethod(method);
- additions.addLiveMethodWithKeepAction(
- bridge, joiner -> joiner.disallowOptimization().disallowShrinking());
}
syntheticInterfaceMethodBridges.clear();
}
@@ -3593,15 +3697,15 @@
rootSet.mayHaveSideEffects,
rootSet.noSideEffects,
rootSet.assumedValues,
- rootSet.alwaysInline,
- rootSet.forceInline,
- rootSet.neverInline,
- rootSet.neverInlineDueToSingleCaller,
- rootSet.whyAreYouNotInlining,
- rootSet.keepConstantArguments,
- rootSet.keepUnusedArguments,
- rootSet.reprocess,
- rootSet.neverReprocess,
+ amendWithCompanionMethods(rootSet.alwaysInline),
+ amendWithCompanionMethods(rootSet.forceInline),
+ amendWithCompanionMethods(rootSet.neverInline),
+ amendWithCompanionMethods(rootSet.neverInlineDueToSingleCaller),
+ amendWithCompanionMethods(rootSet.whyAreYouNotInlining),
+ amendWithCompanionMethods(rootSet.keepConstantArguments),
+ amendWithCompanionMethods(rootSet.keepUnusedArguments),
+ amendWithCompanionMethods(rootSet.reprocess),
+ amendWithCompanionMethods(rootSet.neverReprocess),
rootSet.alwaysClassInline,
rootSet.neverClassInline,
noClassMerging,
@@ -3620,6 +3724,22 @@
return new EnqueuerResult(appInfoWithLiveness);
}
+ private Set<DexMethod> amendWithCompanionMethods(Set<DexMethod> methods) {
+ if (methods.isEmpty() || interfaceProcessor == null) {
+ return methods;
+ }
+ BooleanBox changed = new BooleanBox(false);
+ ImmutableSet.Builder<DexMethod> builder = ImmutableSet.builder();
+ interfaceProcessor.forEachMethodToMove(
+ (method, companion) -> {
+ if (methods.contains(method)) {
+ changed.set(true);
+ builder.add(companion);
+ }
+ });
+ return changed.isTrue() ? builder.addAll(methods).build() : methods;
+ }
+
private boolean verifyReferences(DexApplication app) {
WorkList<DexClass> worklist = WorkList.newIdentityWorkList();
for (DexProgramClass clazz : liveTypes.getItems()) {
@@ -3762,6 +3882,16 @@
continue;
}
+ for (DelayedRootSetActionItem delayedRootSetActionItem :
+ rootSet.delayedRootSetActionItems) {
+ if (delayedRootSetActionItem.isInterfaceMethodSyntheticBridgeAction()) {
+ identifySyntheticInterfaceMethodBridges(
+ delayedRootSetActionItem.asInterfaceMethodSyntheticBridgeAction());
+ }
+ }
+
+ synthesize();
+
ConsequentRootSet consequentRootSet = computeDelayedInterfaceMethodSyntheticBridges();
addConsequentRootSet(consequentRootSet);
rootSet
@@ -3773,11 +3903,6 @@
continue;
}
- synthesize();
- if (!workList.isEmpty()) {
- continue;
- }
-
// Reached the fixpoint.
break;
}
@@ -3808,9 +3933,14 @@
assert workList.isEmpty();
R8PostProcessingDesugaringEventConsumer eventConsumer =
- CfPostProcessingDesugaringEventConsumer.createForR8(syntheticAdditions);
- CfPostProcessingDesugaringCollection.create(appView, null, desugaring.getRetargetingInfo())
- .postProcessingDesugaring(liveTypes.items, eventConsumer, executorService);
+ CfPostProcessingDesugaringEventConsumer.createForR8(syntheticAdditions, desugaring);
+ InterfaceMethodProcessorFacade interfaceDesugaring =
+ desugaring.getInterfaceMethodPostProcessingDesugaringR8(
+ ExcludeDexResources, liveMethods::contains, interfaceProcessor);
+ CfPostProcessingDesugaringCollection.create(
+ appView, interfaceDesugaring, desugaring.getRetargetingInfo())
+ .postProcessingDesugaring(
+ liveTypes.items, liveMethods::contains, eventConsumer, executorService);
if (syntheticAdditions.isEmpty()) {
return;
@@ -3829,8 +3959,6 @@
EnqueuerAction action = workList.poll();
action.run(this);
}
-
- eventConsumer.finalizeDesugaring();
}
private long getNumberOfLiveItems() {
@@ -3846,6 +3974,7 @@
// enqueuer, similar to Enqueuer#dependentMinimumKeepClassInfo.
rootSet.addConsequentRootSet(consequentRootSet);
includeMinimumKeepInfo(consequentRootSet);
+ consequentRootSet.pendingMethodMoveInverse.forEach(pendingMethodMoveInverse::put);
// Check for compatibility rules indicating that the holder must be implicitly kept.
if (forceProguardCompatibility) {
@@ -3873,11 +4002,10 @@
private final Map<DexMethod, ProgramMethod> syntheticInterfaceMethodBridges =
new LinkedHashMap<>();
- private void handleInterfaceMethodSyntheticBridgeAction(
- InterfaceMethodSyntheticBridgeAction action, RootSetBuilder builder) {
+ private void identifySyntheticInterfaceMethodBridges(
+ InterfaceMethodSyntheticBridgeAction action) {
ProgramMethod methodToKeep = action.getMethodToKeep();
ProgramMethod singleTarget = action.getSingleTarget();
- DexEncodedMethod singleTargetMethod = singleTarget.getDefinition();
if (rootSet.isShrinkingDisallowedUnconditionally(singleTarget, options)) {
return;
}
@@ -3886,20 +4014,19 @@
methodToKeep.getDefinition().getReference())) {
syntheticInterfaceMethodBridges.put(
methodToKeep.getDefinition().getReference(), methodToKeep);
- assert null
- == methodToKeep.getHolder().lookupMethod(methodToKeep.getDefinition().getReference());
- if (singleTargetMethod.isLibraryMethodOverride().isTrue()) {
- methodToKeep.getDefinition().setLibraryMethodOverride(OptionalBool.TRUE);
- }
- DexProgramClass singleTargetHolder = singleTarget.getHolder();
- assert singleTargetHolder.isInterface();
- markVirtualMethodAsReachable(
- singleTargetMethod.getReference(),
- singleTargetHolder.isInterface(),
- singleTarget,
- graphReporter.fakeReportShouldNotBeUsed());
- workList.enqueueMarkMethodLiveAction(
- singleTarget, singleTarget, graphReporter.fakeReportShouldNotBeUsed());
+ }
+ }
+
+ private void handleInterfaceMethodSyntheticBridgeAction(
+ InterfaceMethodSyntheticBridgeAction action, RootSetBuilder builder) {
+ ProgramMethod methodToKeep = action.getMethodToKeep();
+ ProgramMethod singleTarget = action.getSingleTarget();
+ DexEncodedMethod singleTargetMethod = singleTarget.getDefinition();
+ if (rootSet.isShrinkingDisallowedUnconditionally(singleTarget, options)) {
+ return;
+ }
+ if (singleTargetMethod.isLibraryMethodOverride().isTrue()) {
+ methodToKeep.getDefinition().setLibraryMethodOverride(OptionalBool.TRUE);
}
action.getAction().accept(builder);
}
@@ -3922,33 +4049,23 @@
DexEncodedMethod definition = target.getDefinition();
DexProgramClass holder = target.getHolder();
DexMethod reference = target.getReference();
+ markMethodAsTargeted(target, reason);
if (definition.isVirtualMethod()) {
// A virtual method. Mark it as reachable so that subclasses, if instantiated, keep
// their overrides. However, we don't mark it live, as a keep rule might not imply that
// the corresponding class is live.
markVirtualMethodAsReachable(reference, holder.isInterface(), target, reason);
- if (holder.isInterface()) {
- // Reachability for default methods is based on live subtypes in general. For keep rules,
- // we need special handling as we essentially might have live subtypes that are outside of
- // the current compilation unit. Keep either the default-method or its implementation
- // method.
+ // When generating interface bridges the method may be inserted into a live hierarchy.
+ // If so we need to also mark it as live as the reachable check above will not reprocess the
+ // hierarchy.
+ // TODO(b/183998768): The check for isInterface here should be possible to remove now.
+ if (definition.isNonAbstractVirtualMethod()
+ && (objectAllocationInfoCollection.isInstantiatedDirectlyOrHasInstantiatedSubtype(holder)
+ || holder.isInterface())) {
// TODO(b/120959039): Codify the kept-graph expectations for these cases in tests.
- if (definition.isNonAbstractVirtualMethod()) {
- markVirtualMethodAsLive(target, reason);
- } else {
- DexEncodedMethod implementation = definition.getDefaultInterfaceMethodImplementation();
- if (implementation != null) {
- DexProgramClass companion =
- asProgramClassOrNull(appInfo().definitionFor(implementation.getHolderType()));
- markTypeAsLive(companion, graphReporter.reportCompanionClass(holder, companion));
- markVirtualMethodAsLive(
- new ProgramMethod(companion, implementation),
- graphReporter.reportCompanionMethod(definition, implementation));
- }
- }
+ markVirtualMethodAsLive(target, reason);
}
} else {
- markMethodAsTargeted(target, reason);
markDirectStaticOrConstructorMethodAsLive(target, reason);
}
}
@@ -4090,9 +4207,10 @@
}
private void traceNonDesugaredCode(ProgramMethod method) {
- if (getMode().isInitialTreeShaking() && desugaring.needsDesugaring(method)) {
- pendingDesugaring.add(method);
- return;
+ if (getMode().isInitialTreeShaking()) {
+ if (addToPendingDesugaring(method)) {
+ return;
+ }
}
traceCode(method);
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
index cd52fd7..ad3d4d1 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
@@ -501,7 +501,8 @@
@Override
boolean enqueueAssertAction(Action assertion) {
- throw attemptToEnqueue();
+ assertion.execute();
+ return true;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
index 0dcddda..c260f3e 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
@@ -244,10 +244,20 @@
this.methodRuleInstances = methodRuleInstances;
}
- public void removeKeepInfoForPrunedItems(Set<DexType> removedClasses) {
- keepClassInfo.keySet().removeIf(removedClasses::contains);
- keepFieldInfo.keySet().removeIf(field -> removedClasses.contains(field.getHolderType()));
- keepMethodInfo.keySet().removeIf(method -> removedClasses.contains(method.getHolderType()));
+ public void removeKeepInfoForPrunedItems(Set<? extends DexReference> removedReferences) {
+ keepClassInfo.keySet().removeIf(removedReferences::contains);
+ keepFieldInfo
+ .keySet()
+ .removeIf(
+ field ->
+ (removedReferences.contains(field)
+ || removedReferences.contains(field.getHolderType())));
+ keepMethodInfo
+ .keySet()
+ .removeIf(
+ method ->
+ (removedReferences.contains(method)
+ || removedReferences.contains(method.getHolderType())));
}
@Override
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
index 73f5c94..72a1510 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
@@ -42,6 +42,8 @@
import com.android.tools.r8.graph.PrunedItems;
import com.android.tools.r8.graph.SubtypingInfo;
import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteBuilderShrinker;
+import com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringSyntheticHelper;
+import com.android.tools.r8.ir.desugar.itf.InterfaceMethodDesugaringBaseEventConsumer;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.shaking.AnnotationMatchResult.AnnotationsIgnoredMatchResult;
@@ -58,6 +60,7 @@
import com.android.tools.r8.utils.PredicateSet;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.collections.ProgramMethodMap;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
@@ -137,6 +140,10 @@
private final OptimizationFeedbackSimple feedback = OptimizationFeedbackSimple.getInstance();
+ private final InterfaceDesugaringSyntheticHelper interfaceDesugaringSyntheticHelper;
+ private final ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse =
+ ProgramMethodMap.create();
+
private RootSetBuilder(
AppView<? extends AppInfoWithClassHierarchy> appView,
SubtypingInfo subtypingInfo,
@@ -146,6 +153,10 @@
this.application = appView.appInfo().app().asDirect();
this.rules = rules;
this.options = appView.options();
+ interfaceDesugaringSyntheticHelper =
+ options.isInterfaceMethodDesugaringEnabled()
+ ? new InterfaceDesugaringSyntheticHelper(appView)
+ : null;
}
private RootSetBuilder(
@@ -383,7 +394,8 @@
dependentKeepClassCompatRule,
identifierNameStrings,
ifRules,
- Lists.newArrayList(delayedRootSetActionItems));
+ Lists.newArrayList(delayedRootSetActionItems),
+ pendingMethodMoveInverse);
}
private void propagateAssumeRules(DexClass clazz) {
@@ -453,7 +465,8 @@
neverClassInline,
dependentMinimumKeepInfo,
dependentKeepClassCompatRule,
- Lists.newArrayList(delayedRootSetActionItems));
+ Lists.newArrayList(delayedRootSetActionItems),
+ pendingMethodMoveInverse);
}
private static DexProgramClass testAndGetPrecondition(
@@ -1333,25 +1346,6 @@
// Don't keep lambda deserialization methods.
return;
}
- // If desugaring is enabled, private and static interface methods will be moved to a
- // companion class. So we don't need to add them to the root set in the beginning.
- if (options.isInterfaceMethodDesugaringEnabled()
- && method.getDefinition().hasCode()
- && (method.getAccessFlags().isPrivate() || method.getAccessFlags().isStatic())) {
- DexClass holder = appView.definitionFor(method.getHolderType());
- if (holder != null && holder.isInterface()) {
- if (rule.isSpecific()) {
- options.reporter.warning(
- new StringDiagnostic(
- "The rule `"
- + rule
- + "` is ignored because the targeting interface method `"
- + method.getReference().toSourceString()
- + "` will be desugared."));
- }
- return;
- }
- }
}
// The reason for keeping should link to the conditional rule as a whole, if present.
@@ -1388,6 +1382,44 @@
preconditionEvent = UnconditionalKeepInfoEvent.get();
}
+ if (isInterfaceMethodNeedingDesugaring(item)) {
+ ProgramMethod method = item.asMethod();
+ ProgramMethod companion =
+ interfaceDesugaringSyntheticHelper.ensureMethodOfProgramCompanionClassStub(
+ method,
+ new InterfaceMethodDesugaringBaseEventConsumer() {
+ @Override
+ public void acceptCompanionClassClinit(ProgramMethod method) {
+ // No processing of synthesized CC.<clinit>. They will be picked up by tracing.
+ }
+
+ @Override
+ public void acceptCompanionMethod(ProgramMethod method, ProgramMethod companion) {
+ // The move will be included in the pending-inverse map below.
+ }
+ });
+ // Add the method to the inverse map as tracing will now directly target the CC method.
+ pendingMethodMoveInverse.put(companion, method);
+ // Only shrinking and optimization are transferred for interface companion methods.
+ if (appView.options().isOptimizationEnabled() && !modifiers.allowsOptimization) {
+ dependentMinimumKeepInfo
+ .getOrCreateMinimumKeepInfoFor(preconditionEvent, companion.getReference())
+ .disallowOptimization();
+ context.markAsUsed();
+ }
+ if (appView.options().isShrinking() && !modifiers.allowsShrinking) {
+ dependentMinimumKeepInfo
+ .getOrCreateMinimumKeepInfoFor(preconditionEvent, companion.getReference())
+ .addRule(keepRule)
+ .disallowShrinking();
+ context.markAsUsed();
+ }
+ if (!item.asMethod().isDefaultMethod()) {
+ // Static and private methods do not apply to the original item.
+ return;
+ }
+ }
+
if (appView.options().isAccessModificationEnabled() && !modifiers.allowsAccessModification) {
dependentMinimumKeepInfo
.getOrCreateMinimumKeepInfoFor(preconditionEvent, item.getReference())
@@ -1436,6 +1468,14 @@
}
}
+ private boolean isInterfaceMethodNeedingDesugaring(ProgramDefinition item) {
+ return options.isInterfaceMethodDesugaringEnabled()
+ && item.isMethod()
+ && item.asMethod().getHolder().isInterface()
+ && !item.asMethod().getDefinition().isClassInitializer()
+ && item.asMethod().getDefinition().hasCode();
+ }
+
private void reportAssumeNoSideEffectsWarningForJavaLangClassMethod(
DexClassAndMethod method, ProguardAssumeNoSideEffectRule context) {
assert method.getHolderType() == options.dexItemFactory().objectType;
@@ -1486,6 +1526,7 @@
private final DependentMinimumKeepInfoCollection dependentMinimumKeepInfo;
final Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule;
final List<DelayedRootSetActionItem> delayedRootSetActionItems;
+ public final ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse;
RootSetBase(
Set<DexMethod> neverInline,
@@ -1493,13 +1534,15 @@
Set<DexType> neverClassInline,
DependentMinimumKeepInfoCollection dependentMinimumKeepInfo,
Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
- List<DelayedRootSetActionItem> delayedRootSetActionItems) {
+ List<DelayedRootSetActionItem> delayedRootSetActionItems,
+ ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
this.neverInline = neverInline;
this.neverInlineDueToSingleCaller = neverInlineDueToSingleCaller;
this.neverClassInline = neverClassInline;
this.dependentMinimumKeepInfo = dependentMinimumKeepInfo;
this.dependentKeepClassCompatRule = dependentKeepClassCompatRule;
this.delayedRootSetActionItems = delayedRootSetActionItems;
+ this.pendingMethodMoveInverse = pendingMethodMoveInverse;
}
Set<ProguardKeepRuleBase> getDependentKeepClassCompatRule(DexType type) {
@@ -1560,14 +1603,16 @@
Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
Set<DexReference> identifierNameStrings,
Set<ProguardIfRule> ifRules,
- List<DelayedRootSetActionItem> delayedRootSetActionItems) {
+ List<DelayedRootSetActionItem> delayedRootSetActionItems,
+ ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
super(
neverInline,
neverInlineDueToSingleCaller,
neverClassInline,
dependentMinimumKeepInfo,
dependentKeepClassCompatRule,
- delayedRootSetActionItems);
+ delayedRootSetActionItems,
+ pendingMethodMoveInverse);
this.reasonAsked = reasonAsked;
this.checkDiscarded = checkDiscarded;
this.alwaysInline = alwaysInline;
@@ -1880,14 +1925,16 @@
Set<DexType> neverClassInline,
DependentMinimumKeepInfoCollection dependentMinimumKeepInfo,
Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
- List<DelayedRootSetActionItem> delayedRootSetActionItems) {
+ List<DelayedRootSetActionItem> delayedRootSetActionItems,
+ ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
super(
neverInline,
neverInlineDueToSingleCaller,
neverClassInline,
dependentMinimumKeepInfo,
dependentKeepClassCompatRule,
- delayedRootSetActionItems);
+ delayedRootSetActionItems,
+ pendingMethodMoveInverse);
}
static ConsequentRootSetBuilder builder(
@@ -1959,7 +2006,8 @@
emptyMap(),
Collections.emptySet(),
ifRules,
- delayedRootSetActionItems);
+ delayedRootSetActionItems,
+ ProgramMethodMap.empty());
}
public static MainDexRootSetBuilder builder(
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index 71ae785..474d1c3 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -731,6 +731,28 @@
return internalEnsureDexProgramClass(kind, fn, onCreationConsumer, outerContext, type, appView);
}
+ public DexClasspathClass ensureFixedClasspathClassFromType(
+ SyntheticKind kind,
+ DexType contextType,
+ AppView<?> appView,
+ Consumer<SyntheticClasspathClassBuilder> fn) {
+ SynthesizingContext outerContext = SynthesizingContext.fromType(contextType);
+ DexType type = SyntheticNaming.createFixedType(kind, outerContext, appView.dexItemFactory());
+ synchronized (contextType) {
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz != null) {
+ assert clazz.isClasspathClass();
+ return clazz.asClasspathClass();
+ }
+ SyntheticClasspathClassBuilder classBuilder =
+ new SyntheticClasspathClassBuilder(type, kind, outerContext, appView.dexItemFactory());
+ fn.accept(classBuilder);
+ DexClasspathClass definition = classBuilder.build();
+ addPendingDefinition(new SyntheticClasspathClassDefinition(kind, outerContext, definition));
+ return definition;
+ }
+ }
+
/** Create a single synthetic method item. */
public ProgramMethod createMethod(
SyntheticKind kind,
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index 216fcfc..0a05c0f 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -39,6 +39,7 @@
HORIZONTAL_INIT_TYPE_ARGUMENT_1(SYNTHETIC_CLASS_SEPARATOR + "IA$1", 6, false, true),
HORIZONTAL_INIT_TYPE_ARGUMENT_2(SYNTHETIC_CLASS_SEPARATOR + "IA$2", 7, false, true),
HORIZONTAL_INIT_TYPE_ARGUMENT_3(SYNTHETIC_CLASS_SEPARATOR + "IA$3", 8, false, true),
+ CONST_DYNAMIC("$Condy", 30, false),
// Method synthetics.
ENUM_UNBOXING_CHECK_NOT_ZERO_METHOD("CheckNotZero", 27, true),
RECORD_HELPER("Record", 9, true),
@@ -53,7 +54,8 @@
SERVICE_LOADER("ServiceLoad", 18, true),
OUTLINE("Outline", 19, true),
API_CONVERSION("APIConversion", 26, true),
- API_CONVERSION_PARAMETERS("APIConversionParameters", 28, true);
+ API_CONVERSION_PARAMETERS("APIConversionParameters", 28, true),
+ EMULATED_INTERFACE_MARKER_CLASS("", 29, false, true, true);
static {
assert verifyNoOverlappingIds();
diff --git a/src/main/java/com/android/tools/r8/utils/DesugarUtils.java b/src/main/java/com/android/tools/r8/utils/DesugarUtils.java
new file mode 100644
index 0000000..7b8fba2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/DesugarUtils.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.utils;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexString;
+
+public class DesugarUtils {
+ public static DexString appendFullyQualifiedHolderToMethodName(
+ DexMethod method, DexItemFactory factory) {
+ return factory.createString(
+ method.name.toString() + "$" + method.holder.getTypeName().replace('.', '-'));
+ }
+}
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 f391fb1..e0a5e76 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -514,15 +514,7 @@
return !canUseNestBasedAccess();
}
- public boolean enableExperimentalRecordDesugaring() {
- // TODO(b/169645628): Remove when records are supported.
- return testing.enableExperimentalRecordDesugaring;
- }
-
public boolean shouldDesugarRecords() {
- if (!enableExperimentalRecordDesugaring()) {
- return false;
- }
return desugarState.isOn() && !canUseRecords();
}
@@ -1222,15 +1214,15 @@
// TODO(b/69963623): enable if everything is ready, including signature rewriting at call sites.
private boolean enableConstantPropagation = false;
private boolean enableExperimentalArgumentPropagation = false;
- private boolean enableTypePropagation = true;
+ private boolean enableDynamicTypePropagation = true;
public void disableOptimization() {
enableConstantPropagation = false;
- enableTypePropagation = false;
+ enableDynamicTypePropagation = false;
}
- public void disableTypePropagationForTesting() {
- enableTypePropagation = false;
+ public void disableDynamicTypePropagationForTesting() {
+ enableDynamicTypePropagation = false;
}
public int getMaxNumberOfDispatchTargetsBeforeAbandoning() {
@@ -1241,7 +1233,7 @@
if (!isOptimizing()) {
return false;
}
- return enableConstantPropagation || enableTypePropagation;
+ return enableConstantPropagation || enableDynamicTypePropagation;
}
public boolean isExperimentalArgumentPropagationEnabled() {
@@ -1252,8 +1244,8 @@
return enableConstantPropagation;
}
- public boolean isTypePropagationEnabled() {
- return enableTypePropagation;
+ public boolean isDynamicTypePropagationEnabled() {
+ return enableDynamicTypePropagation;
}
public void setEnableConstantPropagation() {
@@ -1261,9 +1253,10 @@
enableConstantPropagation = true;
}
- public void setEnableExperimentalArgumentPropagation(
+ public CallSiteOptimizationOptions setEnableExperimentalArgumentPropagation(
boolean enableExperimentalArgumentPropagation) {
this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
+ return this;
}
}
@@ -1552,7 +1545,6 @@
public boolean enableEnumUnboxingDebugLogs = false;
public boolean forceRedundantConstNumberRemoval = false;
public boolean enableExperimentalDesugaredLibraryKeepRuleGenerator = false;
- public boolean enableExperimentalRecordDesugaring = false;
public boolean invertConditionals = false;
public boolean placeExceptionalBlocksLast = false;
public boolean dontCreateMarkerInD8 = false;
@@ -1639,7 +1631,8 @@
public int numberOfProguardIfRuleMemberEvaluations = 0;
}
- public Consumer<ProgramMethod> callSiteOptimizationInfoInspector = null;
+ public Consumer<ProgramMethod> callSiteOptimizationInfoInspector =
+ ConsumerUtils.emptyConsumer();
public Predicate<DexMethod> cfByteCodePassThrough = null;
diff --git a/src/main/java/com/android/tools/r8/utils/ListUtils.java b/src/main/java/com/android/tools/r8/utils/ListUtils.java
index 089154e..891f1c2 100644
--- a/src/main/java/com/android/tools/r8/utils/ListUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ListUtils.java
@@ -25,7 +25,7 @@
* as the singleton list containing {@code v} (i.e., no changes should be made to the given
* element).
*/
- public static <T> List<T> flatMap(
+ public static <T> List<T> flatMapSameType(
List<T> list, Function<T, Collection<T>> fn, List<T> defaultValue) {
List<T> result = null;
for (int i = 0; i < list.size(); i++) {
@@ -48,6 +48,12 @@
return result != null ? result : defaultValue;
}
+ public static <S, T> List<T> flatMap(List<S> list, Function<S, Collection<T>> fn) {
+ List<T> result = new ArrayList<>();
+ list.forEach(element -> result.addAll(fn.apply(element)));
+ return result;
+ }
+
public static <T> List<T> filter(List<T> list, Predicate<? super T> predicate) {
ArrayList<T> filtered = new ArrayList<>(list.size());
list.forEach(
diff --git a/src/main/java/com/android/tools/r8/utils/ZipUtils.java b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
index e7b9b00..da688a8 100644
--- a/src/main/java/com/android/tools/r8/utils/ZipUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
@@ -102,19 +102,24 @@
throws IOException {
try (ZipOutputStream stream =
new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(zipFile)))) {
- for (Path path : filesToZip) {
- ZipEntry zipEntry =
- new ZipEntry(
- StreamSupport.stream(
- Spliterators.spliteratorUnknownSize(
- basePath.relativize(path).iterator(), Spliterator.ORDERED),
- false)
- .map(Path::toString)
- .collect(Collectors.joining("/")));
- stream.putNextEntry(zipEntry);
- Files.copy(path, stream);
- stream.closeEntry();
- }
+ zip(stream, basePath, filesToZip);
+ }
+ }
+
+ public static void zip(ZipOutputStream stream, Path basePath, Collection<Path> filesToZip)
+ throws IOException {
+ for (Path path : filesToZip) {
+ ZipEntry zipEntry =
+ new ZipEntry(
+ StreamSupport.stream(
+ Spliterators.spliteratorUnknownSize(
+ basePath.relativize(path).iterator(), Spliterator.ORDERED),
+ false)
+ .map(Path::toString)
+ .collect(Collectors.joining("/")));
+ stream.putNextEntry(zipEntry);
+ Files.copy(path, stream);
+ stream.closeEntry();
}
}
diff --git a/src/test/examplesAndroidO/invokecustom/TestGenerator.java b/src/test/examplesAndroidO/invokecustom/TestGenerator.java
index 9964ed0..a4cd89a 100644
--- a/src/test/examplesAndroidO/invokecustom/TestGenerator.java
+++ b/src/test/examplesAndroidO/invokecustom/TestGenerator.java
@@ -21,6 +21,8 @@
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
+// TODO(b/167145686): Migrate these tests to the new setup ala
+// InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest
public class TestGenerator {
private final Path classNamePath;
@@ -52,7 +54,6 @@
generateMethodTest6(cw);
generateMethodTest7(cw);
generateMethodTest8(cw);
- generateMethodTest9(cw);
generateMethodTest10(cw);
generateMethodTest11(cw);
generateMethodTest12(cw);
@@ -89,8 +90,6 @@
mv.visitMethodInsn(
Opcodes.INVOKESTATIC, Type.getInternalName(InvokeCustom.class), "test8", "()V", false);
mv.visitMethodInsn(
- Opcodes.INVOKESTATIC, Type.getInternalName(InvokeCustom.class), "test9", "()V", false);
- mv.visitMethodInsn(
Opcodes.INVOKESTATIC, Type.getInternalName(InvokeCustom.class), "test10", "()V", false);
mv.visitMethodInsn(
Opcodes.INVOKESTATIC, Type.getInternalName(InvokeCustom.class), "test11", "()V", false);
@@ -280,29 +279,6 @@
/**
* Generate test with an invokedynamic, a static bootstrap method with an extra arg that is a
- * MethodHandle of kind invoke virtual. The target method is a method into a class implementing
- * an abstract method and that shadows a default method from an interface.
- */
- private void generateMethodTest9(ClassVisitor cv) {
- MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, "test9", "()V",
- null, null);
- MethodType mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class,
- MethodType.class, MethodHandle.class);
- Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, Type.getInternalName(InvokeCustom.class),
- "bsmCreateCallSite", mt.toMethodDescriptorString(), false);
- mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(InvokeCustom.class));
- mv.visitInsn(Opcodes.DUP);
- mv.visitMethodInsn(
- Opcodes.INVOKESPECIAL, Type.getInternalName(InvokeCustom.class), "<init>", "()V", false);
- mv.visitInvokeDynamicInsn("targetMethodTest10", "(Linvokecustom/InvokeCustom;)V", bootstrap,
- new Handle(Opcodes.H_INVOKEVIRTUAL, Type.getInternalName(InvokeCustom.class),
- "targetMethodTest10", "()V", false));
- mv.visitInsn(Opcodes.RETURN);
- mv.visitMaxs(-1, -1);
- }
-
- /**
- * Generate test with an invokedynamic, a static bootstrap method with an extra arg that is a
* MethodHandle of kind get static. The method handle read a static field from a class.
*/
private void generateMethodTest10(ClassVisitor cv) {
diff --git a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
index 848c566..0637a0b 100644
--- a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
+++ b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
@@ -1,8 +1,8 @@
package com.android.tools.r8;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;
@@ -10,7 +10,6 @@
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.utils.AndroidApiLevel;
import java.util.List;
-import org.hamcrest.core.StringContains;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -81,6 +80,7 @@
TestShrinkerBuilder<?, ?, ?, ?, ?> testBuilder =
testForR8(parameters.getBackend())
+ .setMinApi(AndroidApiLevel.B)
.addLibraryProvider(provider)
.addProgramClassFileData(dumpClassWhichUseJava9Flow())
.addKeepMainRule("MySubscriber");
@@ -90,11 +90,18 @@
// java.util.concurrent.Flow$Subscriber is not present in JDK8 rt.jar.
testBuilder.compileWithExpectedDiagnostics(
diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsCount(1);
- assertThat(
- diagnostics.getErrors().get(0).getDiagnosticMessage(),
- StringContains.containsString("java.util.concurrent.Flow$Subscriber"));
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(containsString("java.util.concurrent.Flow$Subscriber")));
+ if (parameters.isCfRuntime()) {
+ diagnostics.assertOnlyErrors();
+ } else {
+ // TODO(b/198368663): R8 will double report missing classes in itf desugaring.
+ diagnostics.assertWarningsMatch(
+ diagnosticMessage(containsString("java.util.concurrent.Flow$Subscriber")));
+ diagnostics.assertErrorsCount(1);
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertInfosCount(0);
+ }
});
} catch (CompilationFailedException e) {
return;
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index f58f1fd..fbf3878 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -644,6 +644,15 @@
// Tests where the output of R8 fails when run with Art.
private static final Multimap<String, TestCondition> failingRunWithArt =
new ImmutableListMultimap.Builder<String, TestCondition>()
+ // The itf cache issue is hit on dx inputs on the runtime with the issue as we no longer
+ // desugar.
+ // TODO(b/198306901): Investigate this behavior change fully. Do we need a workaround?
+ .put(
+ "666-dex-cache-itf",
+ TestCondition.match(
+ TestCondition.tools(DexTool.DX),
+ TestCondition.compilers(CompilerUnderTest.R8),
+ TestCondition.runtimes(DexVm.Version.DEFAULT)))
// The growth limit test fails after processing by R8 because R8 will eliminate an
// "unneeded" const store. The following reflective call to the VM's GC will then see the
// large array as still live and the subsequent allocations will fail to reach the desired
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index a92437f..11b41cc 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -200,7 +200,7 @@
b ->
b.addProguardConfiguration(
getProguardOptionsNPlus(enableProguardCompatibilityMode), Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaringnplus"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 2, "lambdadesugaringnplus"))
.run();
}
diff --git a/src/test/java/com/android/tools/r8/TestAppViewBuilder.java b/src/test/java/com/android/tools/r8/TestAppViewBuilder.java
new file mode 100644
index 0000000..d5ef230
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestAppViewBuilder.java
@@ -0,0 +1,129 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+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.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class TestAppViewBuilder {
+
+ private AndroidApp.Builder builder = AndroidApp.builder();
+ private List<Function<DexItemFactory, List<ProguardConfigurationRule>>> rules = new ArrayList<>();
+ private List<Consumer<InternalOptions>> optionModifications = new ArrayList<>();
+
+ public static TestAppViewBuilder builder() {
+ return new TestAppViewBuilder();
+ }
+
+ private TestAppViewBuilder() {}
+
+ public TestAppViewBuilder addProgramClasses(Class<?>... classes) {
+ return addProgramClasses(Arrays.asList(classes));
+ }
+
+ public TestAppViewBuilder addProgramClasses(Collection<Class<?>> classes) {
+ classes.forEach(clazz -> builder.addProgramFile(ToolHelper.getClassFileForTestClass(clazz)));
+ return this;
+ }
+
+ public TestAppViewBuilder addProgramClassFileData(byte[]... classes) {
+ return addProgramClassFileData(Arrays.asList(classes));
+ }
+
+ public TestAppViewBuilder addProgramClassFileData(Collection<byte[]> classes) {
+ builder.addClassProgramData(classes);
+ return this;
+ }
+
+ public TestAppViewBuilder addAndroidApp(AndroidApp app) {
+ app.getProgramResourceProviders().forEach(builder::addProgramResourceProvider);
+ app.getClasspathResourceProviders().forEach(builder::addClasspathResourceProvider);
+ app.getLibraryResourceProviders().forEach(builder::addLibraryResourceProvider);
+ assert !app.hasMainDexList() : "todo";
+ return this;
+ }
+
+ public TestAppViewBuilder addKeepAllRule() {
+ rules = null;
+ return this;
+ }
+
+ public TestAppViewBuilder addKeepMainRule(Class<?> mainClass) {
+ return addKeepRuleBuilder(
+ factory -> TestBase.buildKeepRuleForClassAndMethods(mainClass, factory));
+ }
+
+ public TestAppViewBuilder addKeepRuleBuilder(
+ Function<DexItemFactory, List<ProguardConfigurationRule>> ruleBuilder) {
+ if (rules != null) {
+ rules.add(ruleBuilder);
+ }
+ return this;
+ }
+
+ public TestAppViewBuilder addOptionsModification(Consumer<InternalOptions> optionsConsumer) {
+ optionModifications.add(optionsConsumer);
+ return this;
+ }
+
+ public AppView<AppInfoWithLiveness> buildWithLiveness() throws Exception {
+ return TestBase.computeAppViewWithLiveness(
+ builder.build(),
+ (rules == null
+ ? null
+ : factory ->
+ TestBase.buildConfigForRules(
+ factory, ListUtils.flatMap(rules, r -> r.apply(factory)))),
+ options -> optionModifications.forEach(consumer -> consumer.accept(options)));
+ }
+
+ public TestAppViewBuilder setMinApi(AndroidApiLevel minApi) {
+ optionModifications.add(options -> options.minApiLevel = minApi);
+ return this;
+ }
+
+ public TestAppViewBuilder addClasspathClasses(Class<?>... classes) {
+ return addClasspathClasses(Arrays.asList(classes));
+ }
+
+ public TestAppViewBuilder addClasspathClasses(Collection<Class<?>> classes) {
+ classes.forEach(clazz -> addClasspathFiles(ToolHelper.getClassFileForTestClass(clazz)));
+ return this;
+ }
+
+ public TestAppViewBuilder addClasspathFiles(Path... files) {
+ return addClasspathFiles(Arrays.asList(files));
+ }
+
+ public TestAppViewBuilder addClasspathFiles(List<Path> files) {
+ builder.addClasspathFiles(files);
+ return this;
+ }
+
+ public TestAppViewBuilder addLibraryFiles(Path... files) {
+ return addLibraryFiles(Arrays.asList(files));
+ }
+
+ public TestAppViewBuilder addLibraryFiles(List<Path> files) {
+ builder.addLibraryFiles(files);
+ return this;
+ }
+
+ public TestAppViewBuilder addTestingAnnotations() {
+ return addProgramClasses(TestBuilder.getTestingAnnotations());
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index f93398c..2ccb378 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -8,7 +8,9 @@
import static com.android.tools.r8.ToolHelper.R8_TEST_BUCKET;
import static com.android.tools.r8.utils.InternalOptions.ASM_VERSION;
import static com.google.common.collect.Lists.cartesianProduct;
+import static com.google.common.io.ByteStreams.toByteArray;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@ -93,6 +95,7 @@
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.io.ByteStreams;
+import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
@@ -775,17 +778,18 @@
protected static AppView<AppInfoWithLiveness> computeAppViewWithLiveness(AndroidApp app)
throws Exception {
- return computeAppViewWithLiveness(app, null, null);
+ return TestAppViewBuilder.builder().addAndroidApp(app).addKeepAllRule().buildWithLiveness();
}
protected static AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
AndroidApp app, Class<?> mainClass) throws Exception {
- return computeAppViewWithLiveness(
- app,
- factory ->
- buildConfigForRules(factory, buildKeepRuleForClassAndMethods(mainClass, factory)));
+ return TestAppViewBuilder.builder()
+ .addAndroidApp(app)
+ .addKeepMainRule(mainClass)
+ .buildWithLiveness();
}
+ // We should try to get rid of this usage of keep rule building which is very internal.
protected static AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
AndroidApp app, Function<DexItemFactory, ProguardConfiguration> keepConfig) throws Exception {
return computeAppViewWithLiveness(app, keepConfig, null);
@@ -1912,4 +1916,54 @@
}
return false;
}
+
+ public static boolean assertProgramsEqual(Path expectedJar, Path actualJar) throws Exception {
+ if (filesAreEqual(expectedJar, actualJar)) {
+ return true;
+ }
+ ArchiveClassFileProvider expected = new ArchiveClassFileProvider(expectedJar);
+ ArchiveClassFileProvider actual = new ArchiveClassFileProvider(actualJar);
+ assertEquals(getSortedDescriptorList(expected), getSortedDescriptorList(actual));
+ for (String descriptor : expected.getClassDescriptors()) {
+ assertArrayEquals(
+ "Class " + descriptor + " differs",
+ getClassAsBytes(expected, descriptor),
+ getClassAsBytes(actual, descriptor));
+ }
+ return false;
+ }
+
+ public static boolean filesAreEqual(Path file1, Path file2) throws IOException {
+ long size = Files.size(file1);
+ long sizeOther = Files.size(file2);
+ if (size != sizeOther) {
+ return false;
+ }
+ if (size < 4096) {
+ return Arrays.equals(Files.readAllBytes(file1), Files.readAllBytes(file2));
+ }
+ int byteRead1 = 0;
+ int byteRead2 = 0;
+ try (FileInputStream fs1 = new FileInputStream(file1.toString());
+ FileInputStream fs2 = new FileInputStream(file2.toString())) {
+ BufferedInputStream bs1 = new BufferedInputStream(fs1);
+ BufferedInputStream bs2 = new BufferedInputStream(fs2);
+ while (byteRead1 == byteRead2 && byteRead1 != -1) {
+ byteRead1 = bs1.read();
+ byteRead2 = bs2.read();
+ }
+ }
+ return byteRead1 == byteRead2;
+ }
+
+ private static List<String> getSortedDescriptorList(ArchiveClassFileProvider inputJar) {
+ ArrayList<String> descriptorList = new ArrayList<>(inputJar.getClassDescriptors());
+ Collections.sort(descriptorList);
+ return descriptorList;
+ }
+
+ private static byte[] getClassAsBytes(ArchiveClassFileProvider inputJar, String descriptor)
+ throws Exception {
+ return toByteArray(inputJar.getProgramResource(descriptor).getByteStream());
+ }
}
diff --git a/src/test/java/com/android/tools/r8/TestParameters.java b/src/test/java/com/android/tools/r8/TestParameters.java
index 1df89b1..7e230ef 100644
--- a/src/test/java/com/android/tools/r8/TestParameters.java
+++ b/src/test/java/com/android/tools/r8/TestParameters.java
@@ -31,6 +31,8 @@
public boolean canUseDefaultAndStaticInterfaceMethods() {
assert isCfRuntime() || isDexRuntime();
+ assert !isCfRuntime() || apiLevel == null
+ : "Use canUseDefaultAndStaticInterfaceMethodsWhenDesugaring when using CF api levels.";
return isCfRuntime()
|| getApiLevel()
.isGreaterThanOrEqualTo(TestBase.apiLevelWithDefaultInterfaceMethodsSupport());
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index 88738f0..fe6cc31 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -106,6 +106,10 @@
return addKeepRules("-dontoptimize");
}
+ public T addDontShrink() {
+ return addKeepRules("-dontshrink");
+ }
+
public T addDontWarn(Class<?>... classes) {
for (Class<?> clazz : classes) {
addDontWarn(clazz.getTypeName());
diff --git a/src/test/java/com/android/tools/r8/apimodel/AndroidApiDatabaseBuilderGeneratorTest.java b/src/test/java/com/android/tools/r8/apimodel/AndroidApiDatabaseBuilderGeneratorTest.java
index 8b3571a..91accca 100644
--- a/src/test/java/com/android/tools/r8/apimodel/AndroidApiDatabaseBuilderGeneratorTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/AndroidApiDatabaseBuilderGeneratorTest.java
@@ -18,7 +18,6 @@
import com.android.tools.r8.TestState;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.apimodel.AndroidApiVersionsXmlParser.ParsedApiClass;
-import com.android.tools.r8.cf.bootstrap.BootstrapCurrentEqualityTest;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.AndroidApiLevel;
@@ -116,7 +115,7 @@
@Test
public void testDatabaseGenerationUpToDate() throws Exception {
- BootstrapCurrentEqualityTest.filesAreEqual(generateJar(), API_DATABASE_JAR);
+ TestBase.filesAreEqual(generateJar(), API_DATABASE_JAR);
}
/**
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
index e997894..a580fb1 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfDefaultInterfaceMethodsTest.java
@@ -6,7 +6,7 @@
import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForMethod;
import static com.android.tools.r8.utils.AndroidApiLevel.L_MR1;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbstract;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -59,22 +59,22 @@
} else {
ClassSubject aSubject = inspector.clazz(A.class);
ClassSubject apiCaller = inspector.clazz(ApiCaller.class);
- assertThat(apiCaller, isPresent());
- MethodSubject callApiLevel = apiCaller.uniqueMethodWithName("callApiLevel");
if (parameters.isCfRuntime()) {
+ assert parameters.canUseDefaultAndStaticInterfaceMethods();
+ assertThat(apiCaller, isPresent());
assertThat(aSubject, isPresent());
+ MethodSubject callApiLevel = apiCaller.uniqueMethodWithName("callApiLevel");
assertThat(callApiLevel, CodeMatchers.invokesMethodWithName("apiLevel22"));
} else {
assert parameters.isDexRuntime();
- // TODO(b/191013385): A has a virtual method that calls callApiLevel on $CC, but
- // that call should be inlined.
- assertThat(aSubject, isPresent());
- assertThat(callApiLevel, isAbstract());
- ClassSubject classSubject = apiCaller.toCompanionClass();
- assertThat(classSubject, isPresent());
- assertEquals(1, classSubject.allMethods().size());
+ assert !parameters.canUseDefaultAndStaticInterfaceMethods();
+ assertThat(apiCaller, isAbsent());
+ assertThat(aSubject, isAbsent());
+ ClassSubject companionClass = apiCaller.toCompanionClass();
+ assertThat(companionClass, isPresent());
+ assertEquals(1, companionClass.allMethods().size());
assertThat(
- classSubject.allMethods().get(0),
+ companionClass.allMethods().get(0),
CodeMatchers.invokesMethodWithName("apiLevel22"));
}
}
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
index 0525cd5..04dc573 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfLambdaTest.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.utils.codeinspector.CodeMatchers;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import java.lang.reflect.Method;
+import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -47,6 +48,7 @@
@Test
public void testR8() throws Exception {
+ Assume.assumeTrue("b/197494749", parameters.canUseDefaultAndStaticInterfaceMethods());
Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
testForR8(parameters.getBackend())
.addProgramClasses(ApiCaller.class, Action.class, Main.class)
@@ -57,7 +59,6 @@
.apply(setMockApiLevelForMethod(apiMethod, L_MR1))
.apply(ApiModelingTestHelper::enableApiCallerIdentification)
.allowAccessModification()
- .noMinification()
.compile()
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfStaticInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfStaticInterfaceMethodsTest.java
index 1e2fd44..086cfa4 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfStaticInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoInliningOfStaticInterfaceMethodsTest.java
@@ -30,7 +30,7 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public ApiModelNoInliningOfStaticInterfaceMethodsTest(TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
index e41bf8d..1a6717f 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
@@ -5,15 +5,12 @@
import static com.android.tools.r8.graph.GenericSignatureIdentityTest.testParseSignaturesInJar;
import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-import static com.google.common.io.ByteStreams.toByteArray;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import com.android.tools.r8.ArchiveClassFileProvider;
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.ExternalR8TestCompileResult;
import com.android.tools.r8.TestBase;
@@ -29,15 +26,9 @@
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.Lists;
-import java.io.BufferedInputStream;
-import java.io.FileInputStream;
import java.io.IOException;
-import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.ClassRule;
@@ -183,8 +174,7 @@
.setMode(CompilationMode.RELEASE)
.compile()
.outputJar();
- assert uploadJarsToCloudStorageIfTestFails(
- BootstrapCurrentEqualityTest::filesAreEqual, runR81, runR82);
+ assert uploadJarsToCloudStorageIfTestFails(TestBase::filesAreEqual, runR81, runR82);
}
@Test
@@ -247,56 +237,6 @@
BootstrapCurrentEqualityTest::assertProgramsEqual, result.outputJar(), runR8R8.outputJar());
}
- public static boolean assertProgramsEqual(Path expectedJar, Path actualJar) throws Exception {
- if (filesAreEqual(expectedJar, actualJar)) {
- return true;
- }
- ArchiveClassFileProvider expected = new ArchiveClassFileProvider(expectedJar);
- ArchiveClassFileProvider actual = new ArchiveClassFileProvider(actualJar);
- assertEquals(getSortedDescriptorList(expected), getSortedDescriptorList(actual));
- for (String descriptor : expected.getClassDescriptors()) {
- assertArrayEquals(
- "Class " + descriptor + " differs",
- getClassAsBytes(expected, descriptor),
- getClassAsBytes(actual, descriptor));
- }
- return false;
- }
-
- public static boolean filesAreEqual(Path file1, Path file2) throws IOException {
- long size = Files.size(file1);
- long sizeOther = Files.size(file2);
- if (size != sizeOther) {
- return false;
- }
- if (size < 4096) {
- return Arrays.equals(Files.readAllBytes(file1), Files.readAllBytes(file2));
- }
- int byteRead1 = 0;
- int byteRead2 = 0;
- try (FileInputStream fs1 = new FileInputStream(file1.toString());
- FileInputStream fs2 = new FileInputStream(file2.toString())) {
- BufferedInputStream bs1 = new BufferedInputStream(fs1);
- BufferedInputStream bs2 = new BufferedInputStream(fs2);
- while (byteRead1 == byteRead2 && byteRead1 != -1) {
- byteRead1 = bs1.read();
- byteRead2 = bs2.read();
- }
- }
- return byteRead1 == byteRead2;
- }
-
- private static List<String> getSortedDescriptorList(ArchiveClassFileProvider inputJar) {
- ArrayList<String> descriptorList = new ArrayList<>(inputJar.getClassDescriptors());
- Collections.sort(descriptorList);
- return descriptorList;
- }
-
- private static byte[] getClassAsBytes(ArchiveClassFileProvider inputJar, String descriptor)
- throws Exception {
- return toByteArray(inputJar.getProgramResource(descriptor).getByteStream());
- }
-
private static TemporaryFolder newTempFolder() throws IOException {
TemporaryFolder tempFolder = new TemporaryFolder(testFolder.newFolder());
tempFolder.create();
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
index 7dd698b..409236d 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
@@ -4,11 +4,8 @@
package com.android.tools.r8.cf.bootstrap;
import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-import static com.google.common.io.ByteStreams.toByteArray;
-import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.ArchiveClassFileProvider;
import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.R8Command;
@@ -21,9 +18,6 @@
import com.google.common.base.Charsets;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -153,27 +147,4 @@
String pgMap = FileUtils.readTextFile(pgMapFile, Charsets.UTF_8);
return new R8Result(processResult, outputJar, pgMap);
}
-
- private static void assertProgramsEqual(Path expectedJar, Path actualJar) throws Exception {
- ArchiveClassFileProvider expected = new ArchiveClassFileProvider(expectedJar);
- ArchiveClassFileProvider actual = new ArchiveClassFileProvider(actualJar);
- assertEquals(getSortedDescriptorList(expected), getSortedDescriptorList(actual));
- for (String descriptor : expected.getClassDescriptors()) {
- assertArrayEquals(
- "Class " + descriptor + " differs",
- getClassAsBytes(expected, descriptor),
- getClassAsBytes(actual, descriptor));
- }
- }
-
- private static List<String> getSortedDescriptorList(ArchiveClassFileProvider inputJar) {
- ArrayList<String> descriptorList = new ArrayList<>(inputJar.getClassDescriptors());
- Collections.sort(descriptorList);
- return descriptorList;
- }
-
- private static byte[] getClassAsBytes(ArchiveClassFileProvider inputJar, String descriptor)
- throws Exception {
- return toByteArray(inputJar.getProgramResource(descriptor).getByteStream());
- }
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java b/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
index e7c5ce1..51e4d41 100644
--- a/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
@@ -7,6 +7,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -20,6 +21,7 @@
import com.android.tools.r8.graph.MethodResolutionResult;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.ProguardConfigurationRule;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.HashSet;
@@ -43,18 +45,18 @@
private AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
Class<?> methodToBeKept, Class<?> classToBeKept) throws Exception {
- return computeAppViewWithLiveness(
- buildClasses(I.class, J.class, K.class, L.class, A.class, Main.class)
- .addLibraryFile(ToolHelper.getJava8RuntimeJar())
- .build(),
- factory ->
- buildConfigForRules(
- factory,
+ return TestAppViewBuilder.builder()
+ .addProgramClasses(I.class, J.class, K.class, L.class, A.class, Main.class)
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+ .addKeepRuleBuilder(
+ factory ->
ImmutableList.<ProguardConfigurationRule>builder()
.addAll(buildKeepRuleForClassAndMethods(methodToBeKept, factory))
.addAll(buildKeepRuleForClass(classToBeKept, factory))
.addAll(buildKeepRuleForClassAndMethods(Main.class, factory))
- .build()));
+ .build())
+ .setMinApi(AndroidApiLevel.N)
+ .buildWithLiveness();
}
@Test
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
index f440689..837f374 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
@@ -9,7 +9,6 @@
import com.android.tools.r8.NoUnusedInterfaceRemoval;
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class PrivateAndInterfaceMethodCollisionTest extends HorizontalClassMergingTestBase {
@@ -24,7 +23,15 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addHorizontallyMergedClassesInspector(
- HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ i -> {
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ i.assertClassesMerged();
+ } else {
+ // With default method desugaring all uses of J::foo are eliminated so A and B
+ // merge.
+ i.assertIsCompleteMergeGroup(A.class, B.class);
+ }
+ })
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoUnusedInterfaceRemovalAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
index 48844ff..c21469c 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
@@ -9,7 +9,6 @@
import com.android.tools.r8.NoUnusedInterfaceRemoval;
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class StaticAndInterfaceMethodCollisionTest extends HorizontalClassMergingTestBase {
@@ -24,7 +23,15 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addHorizontallyMergedClassesInspector(
- HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ i -> {
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ i.assertNoClassesMerged();
+ } else {
+ // When desugaring the call to C.foo in main will be inlined to target the CC.
+ // With J.foo now unused the classes A and B are safe to merge.
+ i.assertIsCompleteMergeGroup(A.class, B.class);
+ }
+ })
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoUnusedInterfaceRemovalAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
index e2eef5f..4e38b33 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
@@ -30,7 +30,9 @@
.addHorizontallyMergedClassesInspector(
inspector ->
inspector
- .assertIsCompleteMergeGroup(I.class, J.class)
+ .applyIf(
+ parameters.canUseDefaultAndStaticInterfaceMethods(),
+ i -> i.assertIsCompleteMergeGroup(I.class, J.class))
.applyIf(
!parameters.canUseDefaultAndStaticInterfaceMethods(),
i -> i.assertIsCompleteMergeGroup(B1.class, B2.class))
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
index 0af1e85..f7f2e0d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.classmerging.horizontal.HorizontalClassMergingTestBase;
import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import org.junit.Assume;
import org.junit.Test;
public class OverrideDefaultMethodTest extends HorizontalClassMergingTestBase {
@@ -23,6 +24,7 @@
@Test
public void testR8() throws Exception {
+ Assume.assumeTrue("b/197494749", parameters.canUseDefaultAndStaticInterfaceMethods());
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
index 0ea8597..313dec7 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
@@ -38,11 +38,17 @@
inspector.assertNoClassesMerged();
} else {
inspector
- .assertClassesNotMerged(A.class, B.class)
.assertIsCompleteMergeGroup(I.class, J.class)
- .assertIsCompleteMergeGroup(
- SyntheticItemsTestUtils.syntheticCompanionClass(I.class),
- SyntheticItemsTestUtils.syntheticCompanionClass(J.class))
+ .applyIf(
+ parameters.canUseDefaultAndStaticInterfaceMethods(),
+ i ->
+ i.assertClassesNotMerged(A.class, B.class)
+ .assertIsCompleteMergeGroup(
+ SyntheticItemsTestUtils.syntheticCompanionClass(I.class),
+ SyntheticItemsTestUtils.syntheticCompanionClass(J.class)))
+ .applyIf(
+ !parameters.canUseDefaultAndStaticInterfaceMethods(),
+ i -> i.assertClassesMerged(A.class, B.class))
.assertNoOtherClassesMerged();
}
})
@@ -56,7 +62,9 @@
onlyIf(parameters.canUseDefaultAndStaticInterfaceMethods(), isPresent()));
assertThat(codeInspector.clazz(Parent.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
+ assertThat(
+ codeInspector.clazz(B.class),
+ onlyIf(parameters.canUseDefaultAndStaticInterfaceMethods(), isPresent()));
assertThat(codeInspector.clazz(C.class), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
index 6f5e761..1ec170d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.dispatch;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -12,7 +13,6 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.classmerging.horizontal.HorizontalClassMergingTestBase;
-import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import org.junit.Test;
public class OverrideMergeAbsentTest extends HorizontalClassMergingTestBase {
@@ -30,14 +30,23 @@
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.addHorizontallyMergedClassesInspector(
- HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ inspector -> {
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ inspector.assertNoClassesMerged();
+ } else {
+ // When desugaring B.m is moved and A and B can be merged.
+ inspector.assertIsCompleteMergeGroup(A.class, B.class);
+ }
+ })
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A", "B", "A", "J")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(J.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
+ assertThat(
+ codeInspector.clazz(B.class),
+ parameters.canUseDefaultAndStaticInterfaceMethods() ? isPresent() : isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupAfterSubclassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupAfterSubclassMergingTest.java
index cc19dd2..6529d20 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupAfterSubclassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupAfterSubclassMergingTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.interfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isImplementing;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -55,11 +56,10 @@
.assertMergedInto(B.class, A.class);
if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
inspector.assertClassesNotMerged(I.class, J.class, K.class);
- } else {
- inspector
- .assertIsCompleteMergeGroup(I.class, J.class)
- .assertClassesNotMerged(K.class);
+ } else if (enableInterfaceMergingInInitial) {
+ inspector.assertIsCompleteMergeGroup(I.class, J.class);
}
+ inspector.assertNoOtherClassesMerged();
})
.addOptionsModification(
options -> {
@@ -82,14 +82,12 @@
assertThat(aClassSubject, isImplementing(inspector.clazz(K.class)));
ClassSubject cClassSubject = inspector.clazz(C.class);
- assertThat(cClassSubject, isPresent());
- assertThat(
- cClassSubject,
- isImplementing(
- inspector.clazz(
- parameters.canUseDefaultAndStaticInterfaceMethods()
- ? J.class
- : I.class)));
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ assertThat(cClassSubject, isPresent());
+ assertThat(cClassSubject, isImplementing(inspector.clazz(J.class)));
+ } else {
+ assertThat(cClassSubject, isAbsent());
+ }
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A", "K", "J");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupClassTest.java
index e18ce93..5ee0365 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupClassTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.interfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isImplementing;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -16,7 +17,9 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -37,6 +40,7 @@
@Test
public void test() throws Exception {
+ Assume.assumeTrue("b/197494749", parameters.canUseDefaultAndStaticInterfaceMethods());
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
@@ -47,7 +51,10 @@
if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
inspector.assertNoClassesMerged();
} else {
- inspector.assertIsCompleteMergeGroup(I.class, J.class);
+ // J is removed as part of desugaring. This enables merging of its CC class.
+ inspector.assertIsCompleteMergeGroup(
+ SyntheticItemsTestUtils.syntheticCompanionClass(J.class),
+ SyntheticItemsTestUtils.syntheticCompanionClass(K.class));
}
})
.enableInliningAnnotations()
@@ -60,19 +67,18 @@
.inspect(
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
- assertThat(aClassSubject, isImplementing(inspector.clazz(K.class)));
-
ClassSubject bClassSubject = inspector.clazz(B.class);
- assertThat(bClassSubject, isPresent());
- assertThat(
- bClassSubject,
- isImplementing(
- inspector.clazz(
- parameters.canUseDefaultAndStaticInterfaceMethods()
- ? J.class
- : I.class)));
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ assertThat(aClassSubject, isPresent());
+ assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
+ assertThat(aClassSubject, isImplementing(inspector.clazz(K.class)));
+ assertThat(bClassSubject, isPresent());
+ assertThat(bClassSubject, isImplementing(inspector.clazz(J.class)));
+ } else {
+ // When desugaring the calls in main will directly target the CC classes.
+ assertThat(aClassSubject, isAbsent());
+ assertThat(bClassSubject, isAbsent());
+ }
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("K", "J");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupLambdaTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupLambdaTest.java
index 2324f03..a1dbbaf 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/CollisionWithDefaultMethodOutsideMergeGroupLambdaTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.interfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isImplementing;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -61,11 +62,15 @@
.inspect(
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- if (parameters.isCfRuntime()) {
- assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ assertThat(aClassSubject, isPresent());
+ if (parameters.isCfRuntime()) {
+ assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
+ } else {
+ assertThat(aClassSubject, isImplementing(inspector.clazz(J.class)));
+ }
} else {
- assertThat(aClassSubject, isImplementing(inspector.clazz(J.class)));
+ assertThat(aClassSubject, isAbsent());
}
})
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/DisjointInterfacesWithDefaultMethodsMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/DisjointInterfacesWithDefaultMethodsMergingTest.java
index 5a656d9..2c40a58 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/DisjointInterfacesWithDefaultMethodsMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/DisjointInterfacesWithDefaultMethodsMergingTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.interfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isImplementing;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -40,7 +41,13 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addHorizontallyMergedClassesInspector(
- inspector -> inspector.assertIsCompleteMergeGroup(I.class, J.class))
+ inspector -> {
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ inspector.assertIsCompleteMergeGroup(I.class, J.class);
+ } else {
+ inspector.assertNoClassesMerged();
+ }
+ })
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoUnusedInterfaceRemovalAnnotations()
@@ -50,8 +57,12 @@
.inspect(
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ assertThat(aClassSubject, isPresent());
+ assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
+ } else {
+ assertThat(aClassSubject, isAbsent());
+ }
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("I", "J");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/NoDefaultMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/NoDefaultMethodMergingTest.java
index a84dbac..f68dd90 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/NoDefaultMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/interfaces/NoDefaultMethodMergingTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.classmerging.horizontal.interfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isImplementing;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -17,6 +18,7 @@
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.HorizontallyMergedClassesInspector;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -42,13 +44,7 @@
.addKeepMainRule(Main.class)
// I and J are not eligible for merging, since they declare the same default method.
.addHorizontallyMergedClassesInspector(
- inspector -> {
- if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
- inspector.assertNoClassesMerged();
- } else {
- inspector.assertIsCompleteMergeGroup(I.class, J.class);
- }
- })
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
@@ -59,10 +55,17 @@
.inspect(
inspector -> {
ClassSubject aClassSubject = inspector.clazz(A.class);
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ if (!parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ // When desugaring, the forwarding methods to the CC.m methods will be inlined and
+ // the class instances become dead code.
+ assertThat(aClassSubject, isAbsent());
+ assertThat(bClassSubject, isAbsent());
+ return;
+ }
assertThat(aClassSubject, isPresent());
assertThat(aClassSubject, isImplementing(inspector.clazz(I.class)));
- ClassSubject bClassSubject = inspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
assertThat(
bClassSubject,
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
index 2f157d0..3b35a12 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
@@ -50,6 +50,7 @@
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
+import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -355,6 +356,7 @@
@Test
public void testNestedDefaultInterfaceMethodsTest() throws Throwable {
+ Assume.assumeTrue("b/197494749", parameters.canUseDefaultAndStaticInterfaceMethods());
String main = "classmerging.NestedDefaultInterfaceMethodsTest";
Path[] programFiles =
new Path[] {
diff --git a/src/test/java/com/android/tools/r8/code/invokedynamic/InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/code/invokedynamic/InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest.java
new file mode 100644
index 0000000..7494b13
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/code/invokedynamic/InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest.java
@@ -0,0 +1,144 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.code.invokedynamic;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import java.lang.invoke.CallSite;
+import java.lang.invoke.ConstantCallSite;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.invoke.MethodType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Test invokedynamic with a static bootstrap method with an extra arg that is a MethodHandle of
+ * kind invoke virtual. The target method is a method into a class implementing an abstract method
+ * and that shadows a default method from an interface.
+ */
+// TODO(b/167145686): Copy this test and implement all of the variants in
+// ...AndroidOTest.invokeCustom... and then delete those tests.
+@RunWith(Parameterized.class)
+public class InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Called I.foo");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withAllRuntimes()
+ .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
+ .enableApiLevelsForCf()
+ .build();
+ }
+
+ public InvokeDynamicVirtualDispatchToDefaultInterfaceMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testReference() throws Exception {
+ testForDesugaring(parameters)
+ .addProgramClasses(I.class, A.class)
+ .addProgramClassFileData(getTransformedTestClass())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ assumeTrue(
+ "Only test one R8/CF build.",
+ parameters.isDexRuntime() || parameters.getApiLevel() == apiLevelWithInvokeCustomSupport());
+ testForR8(parameters.getBackend())
+ .allowAccessModification()
+ .addProgramClasses(I.class, A.class)
+ .addProgramClassFileData(getTransformedTestClass())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(TestClass.class)
+ .addKeepRules("-keepclassmembers class * { *** foo(...); }")
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ private byte[] getTransformedTestClass() throws Exception {
+ ClassReference aClass = Reference.classFromClass(A.class);
+ MethodReference iFoo = Reference.methodFromMethod(I.class.getDeclaredMethod("foo"));
+ MethodReference bsm =
+ Reference.methodFromMethod(
+ TestClass.class.getDeclaredMethod(
+ "bsmCreateCallSite",
+ Lookup.class,
+ String.class,
+ MethodType.class,
+ MethodHandle.class));
+ return transformer(TestClass.class)
+ .transformMethodInsnInMethod(
+ "main",
+ (opcode, owner, name, descriptor, isInterface, visitor) -> {
+ if (name.equals("replaced")) {
+ visitor.visitInvokeDynamicInsn(
+ iFoo.getMethodName(),
+ "(" + aClass.getDescriptor() + ")V",
+ new Handle(
+ Opcodes.H_INVOKESTATIC,
+ bsm.getHolderClass().getBinaryName(),
+ bsm.getMethodName(),
+ bsm.getMethodDescriptor(),
+ false),
+ new Handle(
+ Opcodes.H_INVOKEVIRTUAL,
+ aClass.getBinaryName(),
+ iFoo.getMethodName(),
+ iFoo.getMethodDescriptor(),
+ false));
+ } else {
+ visitor.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+ }
+ })
+ .transform();
+ }
+
+ public interface I {
+
+ default void foo() {
+ System.out.println("Called I.foo");
+ }
+ }
+
+ public static class A implements I {
+ // Instantiation with default from I.
+ }
+
+ static class TestClass {
+
+ public static CallSite bsmCreateCallSite(
+ MethodHandles.Lookup caller, String name, MethodType type, MethodHandle handle)
+ throws Throwable {
+ return new ConstantCallSite(handle);
+ }
+
+ public static void replaced(Object o) {
+ throw new RuntimeException("unreachable!");
+ }
+
+ public static void main(String[] args) {
+ replaced(new A());
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithUnderscoreThisTestRunner.java b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithUnderscoreThisTestRunner.java
index 7cde792..2e9abfb 100644
--- a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithUnderscoreThisTestRunner.java
+++ b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithUnderscoreThisTestRunner.java
@@ -100,9 +100,9 @@
testForD8()
.addProgramClassesAndInnerClasses(CLASS)
.setMinApiThreshold(AndroidApiLevel.K)
- .compile();
+ .compile()
+ .assertNoMessages();
compileResult
- // TODO(b/123506120): Add .assertNoMessages()
.run(parameters.getRuntime(), CLASS)
.assertSuccessWithOutput(EXPECTED);
runDebugger(compileResult.debugConfig(), true);
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarInnerClassesInInterfaces.java b/src/test/java/com/android/tools/r8/desugar/DesugarInnerClassesInInterfaces.java
index 1c8d5b9..8902cd2 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarInnerClassesInInterfaces.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarInnerClassesInInterfaces.java
@@ -4,11 +4,13 @@
package com.android.tools.r8.desugar;
import static com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringForTesting.getCompanionClassNameSuffix;
+import static org.junit.Assume.assumeTrue;
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.utils.AndroidApiLevel;
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.concurrent.Callable;
@@ -30,13 +32,6 @@
WithLocalInner.class.getName() + getCompanionClassNameSuffix(),
"true");
- private final List<String> EXPECTED_RESULT_WITH_DESUGARING_B168697955 =
- ImmutableList.of(
- WithAnonymousInner.class.getName() + getCompanionClassNameSuffix(),
- "false",
- WithLocalInner.class.getName() + getCompanionClassNameSuffix(),
- "false");
-
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
@@ -69,6 +64,7 @@
@Test
public void testR8Compat() throws Exception {
+ assumeTrue(parameters.isDexRuntime() || parameters.getApiLevel() == AndroidApiLevel.B);
testForR8Compat(parameters.getBackend())
.addInnerClasses(DesugarInnerClassesInInterfaces.class)
.setMinApi(parameters.getApiLevel())
@@ -78,37 +74,14 @@
.compile()
.run(parameters.getRuntime(), TestClass.class)
.applyIf(
- parameters.canUseDefaultAndStaticInterfaceMethods(),
+ parameters.isCfRuntime() || parameters.canUseDefaultAndStaticInterfaceMethods(),
result -> result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITHOUT_DESUGARING),
- // The static method which is moved to the companion class is inlined and causing
- // this different output. The rule "-keep class * { *; }" does not keep the static
- // method from being inlined after it has moved. Turning off inlining produces the
- // expected result. The inlining cause the getEnclosingClass() to return null.
- // See b/168697955.
- result ->
- result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITH_DESUGARING_B168697955));
- }
-
- @Test
- public void testR8_B168697955() throws Exception {
- testForR8(parameters.getBackend())
- .addInnerClasses(DesugarInnerClassesInInterfaces.class)
- .setMinApi(parameters.getApiLevel())
- .addKeepAllClassesRule()
- .addKeepAttributeInnerClassesAndEnclosingMethod()
- // With inlining turned off we get the expected result.
- .addOptionsModification(options -> options.enableInlining = false)
- .compile()
- .run(parameters.getRuntime(), TestClass.class)
- .applyIf(
- parameters.canUseDefaultAndStaticInterfaceMethods(),
- result -> result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITHOUT_DESUGARING),
- // TODO(b/187377562): We remove the attribute due to not pinning the moved methods.
- result -> result.assertFailureWithErrorThatThrows(NullPointerException.class));
+ result -> result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITH_DESUGARING));
}
@Test
public void testR8Full() throws Exception {
+ assumeTrue(parameters.isDexRuntime() || parameters.getApiLevel() == AndroidApiLevel.B);
testForR8(parameters.getBackend())
.addInnerClasses(DesugarInnerClassesInInterfaces.class)
.setMinApi(parameters.getApiLevel())
@@ -117,10 +90,9 @@
.compile()
.run(parameters.getRuntime(), TestClass.class)
.applyIf(
- parameters.canUseDefaultAndStaticInterfaceMethods(),
+ parameters.isCfRuntime() || parameters.canUseDefaultAndStaticInterfaceMethods(),
result -> result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITHOUT_DESUGARING),
- // TODO(b/187377562): We remove the attribute due to not pinning the moved methods.
- result -> result.assertFailureWithErrorThatThrows(NullPointerException.class));
+ result -> result.assertSuccessWithOutputLines(EXPECTED_RESULT_WITH_DESUGARING));
}
interface WithAnonymousInner {
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 9691b07..23436d3 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithAnonymousClass.java
@@ -34,7 +34,8 @@
private final List<String> EXPECTED_D8_DESUGARED_RESULT =
ImmutableList.of(
- "Hello from inside lambda$test$0$DesugarLambdaWithAnonymousClass$TestClass",
+ "Hello from inside"
+ + " lambda$test$0$com-android-tools-r8-desugar-DesugarLambdaWithAnonymousClass$TestClass",
"Hello from inside lambda$testStatic$1");
@Parameterized.Parameters(name = "{0}")
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 62c36fd..60fde2f 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarLambdaWithLocalClass.java
@@ -33,7 +33,8 @@
private List<String> EXPECTED_D8_DESUGARED_RESULT =
ImmutableList.of(
- "Hello from inside lambda$test$0$DesugarLambdaWithLocalClass$TestClass",
+ "Hello from inside"
+ + " lambda$test$0$com-android-tools-r8-desugar-DesugarLambdaWithLocalClass$TestClass",
"Hello from inside lambda$testStatic$1");
@Parameterized.Parameters(name = "{0}")
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/BasicConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/BasicConstantDynamicTest.java
index b0d261e..aede694 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/BasicConstantDynamicTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/BasicConstantDynamicTest.java
@@ -4,19 +4,16 @@
package com.android.tools.r8.desugar.constantdynamic;
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
-import static com.android.tools.r8.OriginMatcher.hasParent;
-import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertThrows;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DesugarTestConfiguration;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.cf.CfVersion;
-import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import java.io.IOException;
@@ -40,6 +37,7 @@
}
private static final String EXPECTED_OUTPUT = StringUtils.lines("true", "true");
+ private static final Class<?> MAIN_CLASS = A.class;
@Test
public void testReference() throws Exception {
@@ -49,49 +47,73 @@
testForJvm()
.addProgramClassFileData(getTransformedClasses())
- .run(parameters.getRuntime(), A.class)
+ .run(parameters.getRuntime(), MAIN_CLASS)
.assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
+ public void TestD8Cf() throws Exception {
+ testForDesugaring(parameters)
+ .addProgramClassFileData(getTransformedClasses())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .applyIf(
+ // When not desugaring the CF code requires JDK 11.
+ DesugarTestConfiguration::isNotDesugared,
+ r -> {
+ if (parameters.isCfRuntime()
+ && parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11)) {
+ r.assertSuccessWithOutput(EXPECTED_OUTPUT);
+ } else {
+ r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class);
+ }
+ })
+ .applyIf(
+ DesugarTestConfiguration::isDesugared, r -> r.assertSuccessWithOutput(EXPECTED_OUTPUT));
+ }
+
+ @Test
public void testD8() throws Exception {
assumeTrue(parameters.getRuntime().isDex());
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForD8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForD8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
public void testR8() throws Exception {
assumeTrue(parameters.isDexRuntime() || parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForR8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .addKeepMainRule(A.class)
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MAIN_CLASS)
+ // TODO(b/198142613): There should not be a warnings on class references which are
+ // desugared away.
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ b -> b.addDontWarn("java.lang.invoke.MethodHandles$Lookup"))
+ // TODO(b/198142625): Support CONSTANT_Dynamic output for class files.
+ .applyIf(
+ parameters.isCfRuntime(),
+ r -> {
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ r.compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyErrors();
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString(
+ "Unsupported dynamic constant (not desugaring)")));
+ }));
+ },
+ r ->
+ r.run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT));
}
private byte[] getTransformedClasses() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/cf/ConstantDynamicHolderTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicHolderTest.java
similarity index 79%
rename from src/test/java/com/android/tools/r8/cf/ConstantDynamicHolderTest.java
rename to src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicHolderTest.java
index 1ec23ca..48cbeaf 100644
--- a/src/test/java/com/android/tools/r8/cf/ConstantDynamicHolderTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicHolderTest.java
@@ -2,7 +2,7 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.cf;
+package com.android.tools.r8.desugar.constantdynamic;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
@@ -14,10 +14,12 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.AndroidApiLevel;
import java.io.IOException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
import org.objectweb.asm.ConstantDynamic;
import org.objectweb.asm.Handle;
@@ -25,24 +27,19 @@
@RunWith(Parameterized.class)
public class ConstantDynamicHolderTest extends TestBase {
+ @Parameter() public TestParameters parameters;
+
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters()
- .withCfRuntimesStartingFromIncluding(CfVm.JDK11)
- .withDexRuntimes()
- .withAllApiLevels()
- .build();
- }
-
- final TestParameters parameters;
-
- public ConstantDynamicHolderTest(TestParameters parameters) {
- this.parameters = parameters;
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
}
@Test
public void testReference() throws Exception {
assumeTrue(parameters.isCfRuntime());
+ assumeTrue(parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11));
+ assumeTrue(parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
+
testForJvm()
.addProgramClassFileData(getTransformedMain())
.run(parameters.getRuntime(), Main.class)
@@ -52,17 +49,21 @@
@Test(expected = CompilationFailedException.class)
public void testD8() throws Exception {
assumeTrue(parameters.isDexRuntime());
+
testForD8()
.addProgramClassFileData(getTransformedMain())
.setMinApi(parameters.getApiLevel())
.compileWithExpectedDiagnostics(
diagnostics ->
diagnostics.assertErrorMessageThatMatches(
- containsString("Unsupported dynamic constant")));
+ containsString(
+ "Unsupported dynamic constant (runtime provided bootstrap method)")));
}
@Test(expected = CompilationFailedException.class)
public void testR8() throws Exception {
+ assumeTrue(parameters.isDexRuntime() || parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
+
testForR8(parameters.getBackend())
.addProgramClassFileData(getTransformedMain())
.setMinApi(parameters.getApiLevel())
@@ -70,7 +71,8 @@
.compileWithExpectedDiagnostics(
diagnostics ->
diagnostics.assertErrorMessageThatMatches(
- containsString("Unsupported dynamic constant")));
+ containsString(
+ "Unsupported dynamic constant (runtime provided bootstrap method)")));
}
private byte[] getTransformedMain() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/HierarchyConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/HierarchyConstantDynamicTest.java
new file mode 100644
index 0000000..edc3cab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/HierarchyConstantDynamicTest.java
@@ -0,0 +1,142 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.constantdynamic;
+
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.cf.CfVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HierarchyConstantDynamicTest extends TestBase {
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build());
+ }
+
+ private static final String EXPECTED_OUTPUT = StringUtils.lines("true", "true", "true");
+ private static final Class<?> MAIN_CLASS = A.class;
+
+ @Test
+ public void testReference() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ assumeTrue(parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11));
+ assumeTrue(parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
+
+ testForJvm()
+ .addProgramClassFileData(getTransformedClasses())
+ .run(parameters.getRuntime(), A.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+
+ testForD8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ assumeTrue(parameters.isDexRuntime() || parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
+
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MAIN_CLASS)
+ // TODO(b/198142613): There should not be a warnings on class references which are
+ // desugared away.
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ b -> b.addDontWarn("java.lang.invoke.MethodHandles$Lookup"))
+ // TODO(b/198142625): Support CONSTANT_Dynamic output for class files.
+ .applyIf(
+ parameters.isCfRuntime(),
+ r -> {
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ r.compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyErrors();
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString(
+ "Unsupported dynamic constant (not desugaring)")));
+ }));
+ },
+ r ->
+ r.run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT));
+ }
+
+ private Collection<byte[]> getTransformedClasses() throws IOException {
+ return ImmutableList.of(
+ transformer(A.class)
+ .setVersion(CfVersion.V11)
+ .transformConstStringToConstantDynamic(
+ "condy1", A.class, "myConstant", "constantName", Object.class)
+ .transform(),
+ transformer(B.class)
+ .setVersion(CfVersion.V11)
+ .transformConstStringToConstantDynamic(
+ "condy1", B.class, "myConstant", "constantName", Object.class)
+ .transform());
+ }
+
+ // The name of the bootstrap method is the same in both A and B.
+ public static class A {
+
+ public static Object f() {
+ return "condy1"; // Will be transformed to Constant_DYNAMIC.
+ }
+
+ public static void main(String[] args) {
+ System.out.println(f() != null);
+ System.out.println(B.f() != null);
+ System.out.println(f() != B.f());
+ }
+
+ private static Object myConstant(MethodHandles.Lookup lookup, String name, Class<?> type) {
+ return new Object();
+ }
+ }
+
+ public static class B extends A {
+
+ public static Object f() {
+ return "condy1"; // Will be transformed to Constant_DYNAMIC.
+ }
+
+ private static Object myConstant(MethodHandles.Lookup lookup, String name, Class<?> type) {
+ return new Object();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicTest.java
index d1a4d35..86fad6d 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicTest.java
@@ -3,20 +3,13 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar.constantdynamic;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
-import static com.android.tools.r8.OriginMatcher.hasParent;
import static com.android.tools.r8.utils.DescriptorUtils.JAVA_PACKAGE_SEPARATOR;
import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-import static org.hamcrest.CoreMatchers.allOf;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThrows;
import static org.junit.Assume.assumeTrue;
-import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
@@ -24,7 +17,6 @@
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.cf.CfVersion;
-import com.android.tools.r8.utils.ArchiveResourceProvider;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.ZipUtils;
@@ -45,8 +37,7 @@
@RunWith(Parameterized.class)
public class JacocoConstantDynamicTest extends TestBase {
- @Parameter(0)
- public TestParameters parameters;
+ @Parameter() public TestParameters parameters;
@Parameter(1)
public boolean useConstantDynamic;
@@ -140,25 +131,11 @@
assertFalse(Files.exists(agentOutput));
}
} else {
- assertThrows(
- CompilationFailedException.class,
- () -> {
- ArchiveResourceProvider provider =
- ArchiveResourceProvider.fromArchive(testClasses.getInstrumented(), true);
- testForD8(parameters.getBackend())
- .addProgramResourceProviders(provider)
- .addProgramFiles(ToolHelper.JACOCO_AGENT)
- .setMinApi(parameters.getApiLevel())
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- // Check that the error is reported as an error to the diagnostics handler.
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(provider.getOrigin()))));
- });
- });
+ testForD8(parameters.getBackend())
+ .addProgramFiles(testClasses.getInstrumented())
+ .addProgramFiles(ToolHelper.JACOCO_AGENT)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleNamedConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleNamedConstantDynamicTest.java
index 69cd883..e1574f1 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleNamedConstantDynamicTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleNamedConstantDynamicTest.java
@@ -4,19 +4,16 @@
package com.android.tools.r8.desugar.constantdynamic;
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
-import static com.android.tools.r8.OriginMatcher.hasParent;
-import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertThrows;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DesugarTestConfiguration;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.cf.CfVersion;
-import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import java.io.IOException;
@@ -42,6 +39,7 @@
private static final String EXPECTED_OUTPUT =
StringUtils.lines("true", "true", "true", "true", "true");
+ private static final Class<?> MAIN_CLASS = A.class;
@Test
public void testReference() throws Exception {
@@ -51,28 +49,39 @@
testForJvm()
.addProgramClassFileData(getTransformedClasses())
- .run(parameters.getRuntime(), A.class)
+ .run(parameters.getRuntime(), MAIN_CLASS)
.assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
+ public void TestD8Cf() throws Exception {
+ testForDesugaring(parameters)
+ .addProgramClassFileData(getTransformedClasses())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .applyIf(
+ // When not desugaring the CF code requires JDK 11.
+ DesugarTestConfiguration::isNotDesugared,
+ r -> {
+ if (parameters.isCfRuntime()
+ && parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11)) {
+ r.assertSuccessWithOutput(EXPECTED_OUTPUT);
+ } else {
+ r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class);
+ }
+ })
+ .applyIf(
+ DesugarTestConfiguration::isDesugared, r -> r.assertSuccessWithOutput(EXPECTED_OUTPUT));
+ }
+
+ @Test
public void testD8() throws Exception {
assumeTrue(parameters.isDexRuntime());
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForD8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForD8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
@@ -80,21 +89,34 @@
assumeTrue(
parameters.getRuntime().isDex() || parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForR8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .addKeepMainRule(A.class)
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(A.class)
+ // TODO(b/198142613): There should not be a warnings on class references which are
+ // desugared away.
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ b -> b.addDontWarn("java.lang.invoke.MethodHandles$Lookup"))
+ // TODO(b/198142625): Support CONSTANT_Dynamic output for class files.
+ .applyIf(
+ parameters.isCfRuntime(),
+ r -> {
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ r.compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyErrors();
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString(
+ "Unsupported dynamic constant (not desugaring)")));
+ }));
+ },
+ r ->
+ r.run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT));
}
private byte[] getTransformedClasses() throws IOException {
@@ -138,6 +160,9 @@
}
private static Object myConstant(MethodHandles.Lookup lookup, String name, Class<?> type) {
+ // TODO(b/178172809): Use a un-moddeled library method to prevent R8 from seeing that name
+ // is unused.
+ name.toCharArray();
return new Object();
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleTypesConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleTypesConstantDynamicTest.java
index b04792f..e0082a0 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleTypesConstantDynamicTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/MultipleTypesConstantDynamicTest.java
@@ -4,19 +4,16 @@
package com.android.tools.r8.desugar.constantdynamic;
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
-import static com.android.tools.r8.OriginMatcher.hasParent;
-import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertThrows;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DesugarTestConfiguration;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.cf.CfVersion;
-import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.StringUtils;
import java.io.IOException;
@@ -41,6 +38,7 @@
private static final String EXPECTED_OUTPUT =
StringUtils.lines("true", "true", "true", "true", "true");
+ private static final Class<?> MAIN_CLASS = A.class;
@Test
public void testReference() throws Exception {
@@ -55,23 +53,34 @@
}
@Test
+ public void TestD8Cf() throws Exception {
+ testForDesugaring(parameters)
+ .addProgramClassFileData(getTransformedClasses())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .applyIf(
+ // When not desugaring the CF code requires JDK 11.
+ DesugarTestConfiguration::isNotDesugared,
+ r -> {
+ if (parameters.isCfRuntime()
+ && parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11)) {
+ r.assertSuccessWithOutput(EXPECTED_OUTPUT);
+ } else {
+ r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class);
+ }
+ })
+ .applyIf(
+ DesugarTestConfiguration::isDesugared, r -> r.assertSuccessWithOutput(EXPECTED_OUTPUT));
+ }
+
+ @Test
public void testD8() throws Exception {
assumeTrue(parameters.isDexRuntime());
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForD8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForD8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
@@ -79,21 +88,34 @@
assumeTrue(
parameters.getRuntime().isDex() || parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
- assertThrows(
- CompilationFailedException.class,
- () ->
- testForR8(parameters.getBackend())
- .addProgramClassFileData(getTransformedClasses())
- .setMinApi(parameters.getApiLevel())
- .addKeepMainRule(A.class)
- .compileWithExpectedDiagnostics(
- diagnostics -> {
- diagnostics.assertOnlyErrors();
- diagnostics.assertErrorsMatch(
- allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
- diagnosticOrigin(hasParent(Origin.unknown()))));
- }));
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MAIN_CLASS)
+ // TODO(b/198142613): There should not be a warnings on class references which are
+ // desugared away.
+ .applyIf(
+ parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+ b -> b.addDontWarn("java.lang.invoke.MethodHandles$Lookup"))
+ // TODO(b/198142625): Support CONSTANT_Dynamic output for class files.
+ .applyIf(
+ parameters.isCfRuntime(),
+ r -> {
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ r.compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyErrors();
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString(
+ "Unsupported dynamic constant (not desugaring)")));
+ }));
+ },
+ r ->
+ r.run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT));
}
private byte[] getTransformedClasses() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/SharedBootstrapMethodConstantDynamicTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/SharedBootstrapMethodConstantDynamicTest.java
index 24c9ed8..355a5bd 100644
--- a/src/test/java/com/android/tools/r8/desugar/constantdynamic/SharedBootstrapMethodConstantDynamicTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/SharedBootstrapMethodConstantDynamicTest.java
@@ -44,6 +44,7 @@
private static final String EXPECTED_OUTPUT =
StringUtils.lines("true", "true", "true", "true", "true");
+ private static final Class<?> MAIN_CLASS = A.class;
@Test
public void testReference() throws Exception {
@@ -53,11 +54,28 @@
testForJvm()
.addProgramClassFileData(getTransformedClasses())
- .run(parameters.getRuntime(), A.class)
+ .run(parameters.getRuntime(), MAIN_CLASS)
.assertSuccessWithOutput(EXPECTED_OUTPUT);
}
@Test
+ public void TestD8Cf() throws Exception {
+ assertThrows(
+ CompilationFailedException.class,
+ () ->
+ testForD8(Backend.CF)
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyErrors();
+ diagnostics.assertErrorsMatch(
+ diagnosticMessage(
+ containsString("Unsupported dynamic constant (different owner)")));
+ }));
+ }
+
+ @Test
public void testD8() throws Exception {
assumeTrue(parameters.isDexRuntime());
@@ -72,7 +90,8 @@
diagnostics.assertOnlyErrors();
diagnostics.assertErrorsMatch(
allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
+ diagnosticMessage(
+ containsString("Unsupported dynamic constant (different owner)")),
diagnosticOrigin(hasParent(Origin.unknown()))));
}));
}
@@ -87,13 +106,14 @@
testForR8(parameters.getBackend())
.addProgramClassFileData(getTransformedClasses())
.setMinApi(parameters.getApiLevel())
- .addKeepMainRule(A.class)
+ .addKeepMainRule(MAIN_CLASS)
.compileWithExpectedDiagnostics(
diagnostics -> {
diagnostics.assertOnlyErrors();
diagnostics.assertErrorsMatch(
allOf(
- diagnosticMessage(containsString("Unsupported dynamic constant")),
+ diagnosticMessage(
+ containsString("Unsupported dynamic constant (different owner)")),
diagnosticOrigin(hasParent(Origin.unknown()))));
}));
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
index f253398..5e1b8c0 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/LintFilesTest.java
@@ -26,7 +26,6 @@
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
-import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -113,10 +112,6 @@
@Test
public void testFileContent() throws Exception {
- // Test require r8.jar not r8lib.jar, as the class com.android.tools.r8.GenerateLintFiles in
- // not kept.
- Assume.assumeTrue(!ToolHelper.isTestingR8Lib());
-
Path directory = temp.newFolder().toPath();
GenerateLintFiles.main(
new String[] {
@@ -131,6 +126,9 @@
.parse(StringResource.fromFile(ToolHelper.getDesugarLibJsonForTesting()));
for (AndroidApiLevel apiLevel : AndroidApiLevel.values()) {
+ if (apiLevel == AndroidApiLevel.UNKNOWN) {
+ continue;
+ }
Path compileApiLevelDirectory = directory.resolve("compile_api_level_" + apiLevel.getLevel());
if (apiLevel.getLevel()
< desugaredLibraryConfiguration.getRequiredCompilationApiLevel().getLevel()) {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
index bb66f2e..01eb3b8 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/R8CompiledThroughDexTest.java
@@ -12,13 +12,13 @@
import com.android.tools.r8.R8;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.R8Command.Builder;
+import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.cf.bootstrap.BootstrapCurrentEqualityTest;
import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.Pair;
@@ -166,7 +166,7 @@
+ " differ from the external run which uses "
+ r8jar
+ ". If up-to-date, the likely cause of this error is that R8 is non-deterministic.",
- BootstrapCurrentEqualityTest.filesAreEqual(outputThroughCf, outputThroughCfExternal));
+ TestBase.filesAreEqual(outputThroughCf, outputThroughCfExternal));
}
// Finally compile R8 on the ART runtime using the already compiled DEX version of R8.
@@ -194,7 +194,7 @@
assertEquals(0, artProcessResult.exitCode);
assertTrue(
"The output of R8/JVM in-process and R8/ART external differ.",
- BootstrapCurrentEqualityTest.filesAreEqual(outputThroughCf, outputThroughDex));
+ TestBase.filesAreEqual(outputThroughCf, outputThroughDex));
}
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java b/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
index e7cc9c9..9a47de9 100644
--- a/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/enclosingmethod/EnclosingMethodRewriteTest.java
@@ -6,7 +6,6 @@
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.assertNull;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.TestBase;
@@ -73,8 +72,6 @@
"interface " + A.class.getTypeName(), "public int " + A.class.getTypeName() + ".def()", "42"
};
- private final String[] EXPECTED_FULL = new String[] {"null", "null", "42"};
-
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
return getTestParameters().withAllRuntimesAndApiLevels().build();
@@ -102,7 +99,7 @@
.addKeepAttributeInnerClassesAndEnclosingMethod()
.setMinApi(parameters.getApiLevel())
.compile()
- .inspect(inspector -> inspect(inspector, true))
+ .inspect(this::inspect)
.run(parameters.getRuntime(), MAIN)
.applyIf(
parameters.canUseDefaultAndStaticInterfaceMethods(),
@@ -126,8 +123,7 @@
.addKeepAttributeInnerClassesAndEnclosingMethod()
.setMinApi(parameters.getApiLevel())
.compile()
- .inspect(
- inspector -> inspect(inspector, parameters.canUseDefaultAndStaticInterfaceMethods()))
+ .inspect(this::inspect)
.run(parameters.getRuntime(), MAIN)
.applyIf(
parameters.canUseDefaultAndStaticInterfaceMethods(),
@@ -139,25 +135,21 @@
result.assertSuccessWithOutputLines(EXPECTED);
}
},
- result -> result.assertSuccessWithOutputLines(EXPECTED_FULL));
+ result -> result.assertSuccessWithOutputLines(EXPECTED_CC));
}
- private void inspect(CodeInspector inspector, boolean hasEnclosingMethod) {
+ private void inspect(CodeInspector inspector) {
ClassSubject cImplSubject = inspector.clazz(A.class.getTypeName() + "$1");
assertThat(cImplSubject, isPresent());
ClassSubject enclosingClassSubject =
parameters.canUseDefaultAndStaticInterfaceMethods()
? inspector.clazz(A.class.getTypeName())
- : inspector.clazz(A.class.getTypeName() + "$-CC");
+ : inspector.clazz(A.class.getTypeName()).toCompanionClass();
assertThat(enclosingClassSubject, isPresent());
EnclosingMethodAttribute enclosingMethodAttribute =
cImplSubject.getDexProgramClass().getEnclosingMethodAttribute();
- if (hasEnclosingMethod) {
- assertEquals(
- enclosingClassSubject.getDexProgramClass().getType(),
- enclosingMethodAttribute.getEnclosingMethod().getHolderType());
- } else {
- assertNull(enclosingMethodAttribute);
- }
+ assertEquals(
+ enclosingClassSubject.getDexProgramClass().getType(),
+ enclosingMethodAttribute.getEnclosingMethod().getHolderType());
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/OverlappingLambdaMethodInSubclassWithSameNameTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/OverlappingLambdaMethodInSubclassWithSameNameTest.java
new file mode 100644
index 0000000..9f5fa37
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/OverlappingLambdaMethodInSubclassWithSameNameTest.java
@@ -0,0 +1,73 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.desugar.lambdas.b197625454.OverlappingLambdaMethodInSubclassWithSameNameTestA;
+import com.android.tools.r8.desugar.lambdas.b197625454.OverlappingLambdaMethodInSubclassWithSameNameTestB;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+
+// See b/197625454 for details.
+@RunWith(Parameterized.class)
+public class OverlappingLambdaMethodInSubclassWithSameNameTest extends TestBase {
+
+ static final String EXPECTED =
+ StringUtils.lines("Superclass lambda: Hello!", "Superclass lambda: Hello!");
+
+ private static final Class<?> MAIN_CLASS =
+ com.android.tools.r8.desugar.lambdas.b197625454.subpackage
+ .OverlappingLambdaMethodInSubclassWithSameNameTestA.class;
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForRuntime(parameters)
+ .addProgramClasses(
+ MAIN_CLASS,
+ OverlappingLambdaMethodInSubclassWithSameNameTestA.class,
+ OverlappingLambdaMethodInSubclassWithSameNameTestB.class)
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ testForD8(parameters.getBackend())
+ .addProgramClasses(
+ MAIN_CLASS,
+ OverlappingLambdaMethodInSubclassWithSameNameTestA.class,
+ OverlappingLambdaMethodInSubclassWithSameNameTestB.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(
+ MAIN_CLASS,
+ OverlappingLambdaMethodInSubclassWithSameNameTestA.class,
+ OverlappingLambdaMethodInSubclassWithSameNameTestB.class)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MAIN_CLASS)
+ .run(parameters.getRuntime(), MAIN_CLASS)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestA.java b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestA.java
new file mode 100644
index 0000000..25be7d6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestA.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas.b197625454;
+
+// Same base class name as the class it extends. See b/197625454 for details.
+public class OverlappingLambdaMethodInSubclassWithSameNameTestA
+ extends com.android.tools.r8.desugar.lambdas.b197625454.subpackage
+ .OverlappingLambdaMethodInSubclassWithSameNameTestA {
+
+ @Override
+ public void myMethod() {
+ super.myMethod();
+ if (Math.random() < 0) { // always false
+ Runnable local = () -> System.out.println("Subclass lambda: " + getString());
+ }
+ r.run();
+ }
+
+ @Override
+ public String getString() {
+ return "Hello!";
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestB.java b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestB.java
new file mode 100644
index 0000000..45193ef
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/OverlappingLambdaMethodInSubclassWithSameNameTestB.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas.b197625454;
+
+import com.android.tools.r8.desugar.lambdas.b197625454.subpackage.OverlappingLambdaMethodInSubclassWithSameNameTestA;
+
+public class OverlappingLambdaMethodInSubclassWithSameNameTestB
+ extends OverlappingLambdaMethodInSubclassWithSameNameTestA {
+
+ @Override
+ public void myMethod() {
+ super.myMethod();
+ if (Math.random() < 0) { // always false
+ Runnable local = () -> System.out.println("Subclass lambda: " + getString());
+ }
+ r.run();
+ }
+
+ @Override
+ public String getString() {
+ return "Hello!";
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/subpackage/OverlappingLambdaMethodInSubclassWithSameNameTestA.java b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/subpackage/OverlappingLambdaMethodInSubclassWithSameNameTestA.java
new file mode 100644
index 0000000..3f8bdcd
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/b197625454/subpackage/OverlappingLambdaMethodInSubclassWithSameNameTestA.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.lambdas.b197625454.subpackage;
+
+import com.android.tools.r8.desugar.lambdas.b197625454.OverlappingLambdaMethodInSubclassWithSameNameTestB;
+
+public abstract class OverlappingLambdaMethodInSubclassWithSameNameTestA {
+
+ public Runnable r;
+
+ public void myMethod() {
+ r = () -> System.out.println("Superclass lambda: " + getString());
+ }
+
+ public abstract String getString();
+
+ public static void main(String[] args) {
+ new com.android.tools.r8.desugar.lambdas.b197625454
+ .OverlappingLambdaMethodInSubclassWithSameNameTestA()
+ .myMethod();
+ new OverlappingLambdaMethodInSubclassWithSameNameTestB().myMethod();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
index 389744e..10e2d10 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
@@ -55,7 +55,6 @@
.addProgramClassFileData(PROGRAM_DATA)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -72,7 +71,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
@@ -89,7 +87,6 @@
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java b/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java
deleted file mode 100644
index 7064af6..0000000
--- a/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.desugar.records;
-
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertThrows;
-
-import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestDiagnosticMessages;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestRuntime.CfRuntime;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.util.List;
-import org.junit.Assume;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-/** Remove this test when Records are supported by default. */
-@RunWith(Parameterized.class)
-public class InvalidRecordAttributeTest extends TestBase {
-
- private final TestParameters parameters;
- private final Backend backend;
-
- private static final String EMPTY_RECORD = "EmptyRecord";
- private static final byte[][] EMPTY_RECORD_PROGRAM_DATA =
- RecordTestUtils.getProgramData(EMPTY_RECORD);
- private static final String SIMPLE_RECORD = "SimpleRecord";
- private static final byte[][] SIMPLE_RECORD_PROGRAM_DATA =
- RecordTestUtils.getProgramData(SIMPLE_RECORD);
-
- @Parameters(name = "{0} back: {1}")
- public static List<Object[]> data() {
- // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk16).
- return buildParameters(
- getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk16()).build(),
- Backend.values());
- }
-
- public InvalidRecordAttributeTest(TestParameters parameters, Backend backend) {
- this.parameters = parameters;
- this.backend = backend;
- }
-
- @Test
- public void testD8EmptyRecord() throws Exception {
- Assume.assumeTrue(backend.isDex());
- assertThrows(
- CompilationFailedException.class,
- () -> {
- testForD8(backend)
- .addProgramClassFileData(EMPTY_RECORD_PROGRAM_DATA)
- .setMinApi(AndroidApiLevel.B)
- .compileWithExpectedDiagnostics(
- InvalidRecordAttributeTest::assertUnsupportedRecordError);
- });
- }
-
- @Test
- public void testD8SimpleRecord() throws Exception {
- Assume.assumeTrue(backend.isDex());
- assertThrows(
- CompilationFailedException.class,
- () -> {
- testForD8(backend)
- .addProgramClassFileData(RecordTestUtils.getProgramData(SIMPLE_RECORD))
- .setMinApi(AndroidApiLevel.B)
- .compileWithExpectedDiagnostics(
- InvalidRecordAttributeTest::assertUnsupportedRecordError);
- });
- }
-
- @Test
- public void testR8EmptyRecord() throws Exception {
- assertThrows(
- CompilationFailedException.class,
- () -> {
- testForR8(backend)
- .addProgramClassFileData(EMPTY_RECORD_PROGRAM_DATA)
- .setMinApi(AndroidApiLevel.B)
- .addKeepMainRule(RecordTestUtils.getMainType(EMPTY_RECORD))
- .compileWithExpectedDiagnostics(
- InvalidRecordAttributeTest::assertUnsupportedRecordError);
- });
- }
-
- @Test
- public void testR8SimpleRecord() throws Exception {
- assertThrows(
- CompilationFailedException.class,
- () -> {
- testForR8(backend)
- .addProgramClassFileData(SIMPLE_RECORD_PROGRAM_DATA)
- .setMinApi(AndroidApiLevel.B)
- .addKeepMainRule(RecordTestUtils.getMainType(SIMPLE_RECORD))
- .compileWithExpectedDiagnostics(
- InvalidRecordAttributeTest::assertUnsupportedRecordError);
- });
- }
-
- private static void assertUnsupportedRecordError(TestDiagnosticMessages diagnostics) {
- diagnostics.assertErrorThatMatches(
- diagnosticMessage(containsString("Records are not supported")));
- }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java
index 08b0e85..d6639de 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java
@@ -55,7 +55,7 @@
.addProgramClassFileData(PROGRAM_DATA)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
+
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -72,7 +72,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
@@ -89,7 +88,6 @@
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomSplitDesugaringTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomSplitDesugaringTest.java
new file mode 100644
index 0000000..0383285
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomSplitDesugaringTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.records;
+
+import static com.android.tools.r8.desugar.records.RecordTestUtils.RECORD_KEEP_RULE;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.InternalOptions.TestingOptions;
+import com.android.tools.r8.utils.StringUtils;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RecordInvokeCustomSplitDesugaringTest extends TestBase {
+
+ private static final String RECORD_NAME = "RecordInvokeCustom";
+ private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+ private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+ private static final String EXPECTED_RESULT =
+ StringUtils.lines(
+ "Empty[]",
+ "true",
+ "true",
+ "true",
+ "true",
+ "true",
+ "false",
+ "true",
+ "true",
+ "false",
+ "false",
+ "Person[name=Jane Doe, age=42]");
+
+ private final TestParameters parameters;
+
+ public RecordInvokeCustomSplitDesugaringTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Parameterized.Parameters(name = "{0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withDexRuntimes().withAllApiLevelsAlsoForCf().build());
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ Path desugared =
+ testForD8(Backend.CF)
+ .addProgramClassFileData(PROGRAM_DATA)
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+ .compile()
+ .writeToZip();
+ testForD8(parameters.getBackend())
+ .addProgramFiles(desugared)
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+ .compile()
+ .run(parameters.getRuntime(), MAIN_TYPE)
+ .assertSuccessWithOutput(EXPECTED_RESULT);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ Path desugared =
+ testForD8(Backend.CF)
+ .addProgramClassFileData(PROGRAM_DATA)
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+ .compile()
+ .writeToZip();
+ testForR8(parameters.getBackend())
+ .addProgramFiles(desugared)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepRules(RECORD_KEEP_RULE)
+ .addKeepMainRule(MAIN_TYPE)
+ .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+ .compile()
+ .run(parameters.getRuntime(), MAIN_TYPE)
+ .assertSuccessWithOutput(EXPECTED_RESULT);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java
index 9bf3327..dac4ff8 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java
@@ -68,7 +68,7 @@
.addProgramClassFileData(PROGRAM_DATA)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
+
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -85,7 +85,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
@@ -102,7 +101,6 @@
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
index 240e128..ef11ef4 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
@@ -56,7 +56,6 @@
.addProgramClassFileData(PROGRAM_DATA_1)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
Path output2 =
@@ -64,7 +63,6 @@
.addProgramClassFileData(PROGRAM_DATA_2)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
D8TestCompileResult result =
@@ -84,7 +82,6 @@
.addProgramClassFileData(PROGRAM_DATA_1)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
D8TestCompileResult result =
@@ -93,7 +90,6 @@
.addProgramClassFileData(PROGRAM_DATA_2)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile();
result.run(parameters.getRuntime(), MAIN_TYPE_1).assertSuccessWithOutput(EXPECTED_RESULT_1);
result.run(parameters.getRuntime(), MAIN_TYPE_2).assertSuccessWithOutput(EXPECTED_RESULT_2);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java
index 9663f43..e67ccd5 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java
@@ -67,7 +67,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
index 86e30a6..bf74698 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
@@ -99,8 +99,7 @@
}
public static void assertRecordsAreRecords(Path output) throws IOException {
- CodeInspector inspector =
- new CodeInspector(output, opt -> opt.testing.enableExperimentalRecordDesugaring = true);
+ CodeInspector inspector = new CodeInspector(output);
for (FoundClassSubject clazz : inspector.allClasses()) {
if (clazz.getDexProgramClass().superType.toString().equals("java.lang.Record")) {
assertTrue(clazz.getDexProgramClass().isRecord());
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
index 36b2377..cff0cab 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
@@ -57,7 +57,6 @@
.addProgramClassFileData(PROGRAM_DATA)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -74,7 +73,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
@@ -91,7 +89,6 @@
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
index 08c9468..40f8af0 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
@@ -56,7 +56,6 @@
.addProgramClassFileData(PROGRAM_DATA)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
@@ -73,7 +72,6 @@
.addKeepMainRule(MAIN_TYPE)
.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.writeToZip();
RecordTestUtils.assertRecordsAreRecords(output);
@@ -90,7 +88,6 @@
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
.addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
- .addOptionsModification(opt -> opt.testing.enableExperimentalRecordDesugaring = true)
.compile()
.run(parameters.getRuntime(), MAIN_TYPE)
.assertSuccessWithOutput(EXPECTED_RESULT);
diff --git a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java
index 35e52b4..8cd35aa 100644
--- a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.desugar.staticinterfacemethod.InvokeStaticDesugarTest.Library.foo;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeFalse;
@@ -151,12 +152,14 @@
private Set<FoundMethodSubject> getSyntheticMethods(CodeInspector inspector) {
Set<FoundMethodSubject> methods = new HashSet<>();
- assert inspector.allClasses().stream()
- .allMatch(
+ inspector
+ .allClasses()
+ .forEach(
c ->
- !SyntheticItemsTestUtils.isExternalSynthetic(c.getFinalReference())
- || SyntheticItemsTestUtils.isExternalStaticInterfaceCall(
- c.getFinalReference()));
+ assertTrue(
+ !SyntheticItemsTestUtils.isExternalSynthetic(c.getFinalReference())
+ || SyntheticItemsTestUtils.isExternalStaticInterfaceCall(
+ c.getFinalReference())));
inspector.allClasses().stream()
.filter(c -> SyntheticItemsTestUtils.isExternalStaticInterfaceCall(c.getFinalReference()))
.forEach(c -> methods.addAll(c.allMethods(m -> !m.isInstanceInitializer())));
diff --git a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MutuallyRecursiveMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MutuallyRecursiveMethodsTest.java
index ee911d3..dfbbd6e 100644
--- a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MutuallyRecursiveMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/MutuallyRecursiveMethodsTest.java
@@ -35,6 +35,16 @@
.assertSuccessWithOutput(EXPECTED);
}
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(MutuallyRecursiveMethodsTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(TestClass.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
interface I {
static boolean isEven(int i) {
return i == 0 || isOdd(i - 1);
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionInvokeVirtualTest.java
index 12869e2..c960b33 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionInvokeVirtualTest.java
@@ -102,22 +102,21 @@
private void checkResult(TestRunResult<?> result, boolean isR8) {
// Invalid invoke case is where the invoke-virtual targets C.m.
if (invalidInvoke) {
- if (parameters.isCfRuntime()) {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- return;
- }
- if (parameters.getDexRuntimeVersion().isInRangeInclusive(Version.V5_1_1, Version.V7_0_0)) {
+ if (parameters.isDexRuntimeVersion(Version.V7_0_0)
+ && parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring()) {
+ // The v7 VM incorrectly fails to throw.
result.assertSuccessWithOutput(EXPECTED);
- return;
+ } else {
+ result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
return;
}
if (isR8
&& parameters.isDexRuntime()
&& parameters.getDexRuntimeVersion().isNewerThan(Version.V6_0_1)
- && parameters.getDexRuntimeVersion().isOlderThan(Version.V12_0_0)) {
+ && parameters.getDexRuntimeVersion().isOlderThan(Version.V12_0_0)
+ && parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring()) {
// TODO(b/182255398): This should be EXPECTED.
result.assertSuccessWithOutput(EXPECTED_R8);
return;
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionOnClassTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionOnClassTest.java
index 1684c5a..b5949f7 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionOnClassTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/DefaultInterfaceMethodDesugaringWithPublicStaticResolutionOnClassTest.java
@@ -70,10 +70,9 @@
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
- // TODO(b/182335909): Ideally, this should also throw ICCE when desugaring.
.applyIf(
- !parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring()
- || parameters.isDexRuntimeVersion(Version.V7_0_0),
+ parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring()
+ && parameters.isDexRuntimeVersion(Version.V7_0_0),
r -> r.assertSuccessWithOutput(EXPECTED_INVALID),
r -> r.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class));
}
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodToNonImmediateInterfaceTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodToNonImmediateInterfaceTest.java
index 698cf50..f4fec42 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodToNonImmediateInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InvokeSuperInDefaultInterfaceMethodToNonImmediateInterfaceTest.java
@@ -16,6 +16,7 @@
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.ImmutableList;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -36,6 +37,11 @@
}
@Test
+ @Ignore("b/197494749 and b/120130831")
+ // TODO(b/197494749): Update this test now that desugaring is moved up. In particular this must
+ // be rewritten with CF based transformers as R8 does not support interface desugaring on DEX.
+ // TODO(b/120130831): With the move of desugaring this issue should be resolved. The bug indicates
+ // that a workaround for issues related to the IR implementation can now be reverted.
public void test() throws Exception {
// Note that the expected output is independent of the presence of J.m().
String expectedOutput = StringUtils.lines("I.m()", "JImpl.m()");
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 2f27855..3bc5c02 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
@@ -59,9 +59,12 @@
SuccessUnusedDefaultMethod.EnumInterface.class,
SuccessUnusedDefaultMethodOverride.EnumInterface.class,
SuccessUnusedDefaultMethodOverrideEnum.EnumInterface.class)
- .assertNotUnboxed(
- FailureDefaultMethodUsed.EnumInterface.class,
- FailureUsedAsInterface.EnumInterface.class))
+ .assertNotUnboxed(FailureUsedAsInterface.EnumInterface.class)
+ // When desugaring interfaces the dispatch will inline the forwarding method
+ // to the CC method allowing unboxing.
+ .assertUnboxedIf(
+ !parameters.canUseDefaultAndStaticInterfaceMethods(),
+ FailureDefaultMethodUsed.EnumInterface.class))
.noMinification()
.enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
index 509bfa2..99ab7b3 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
@@ -38,9 +38,9 @@
.addProgramClasses(I.class)
.addProgramClassFileData(getClassWithTransformedInvoked())
.run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatThrowsIf(parameters.isCfRuntime(), VerifyError.class)
// TODO(b/144410139): Consider making this a compilation failure when generating DEX.
- .assertSuccessWithOutputLinesIf(parameters.isDexRuntime(), "Hello World!")
- .assertFailureWithErrorThatThrowsIf(parameters.isCfRuntime(), VerifyError.class);
+ .assertSuccessWithOutputLinesIf(parameters.isDexRuntime(), "Hello World!");
}
@Test
@@ -52,11 +52,14 @@
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
- .assertFailureWithErrorThatThrows(
- parameters.isCfRuntime()
- ? VerifyError.class
- // TODO(b/144410139): Consider making this a compilation failure.
- : NullPointerException.class);
+ .assertFailureWithErrorThatThrowsIf(parameters.isCfRuntime(), VerifyError.class)
+ // TODO(b/144410139): Consider making this a compilation failure when generating DEX.
+ .assertSuccessWithOutputLinesIf(
+ parameters.isDexRuntime() && !parameters.canUseDefaultAndStaticInterfaceMethods(),
+ "Hello World!")
+ .assertFailureWithErrorThatThrowsIf(
+ parameters.isDexRuntime() && parameters.canUseDefaultAndStaticInterfaceMethods(),
+ NullPointerException.class);
}
private byte[] getClassWithTransformedInvoked() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/graph/invokevirtual/InvokeVirtualPrivateBaseWithDefaultDirectInvokeTest.java b/src/test/java/com/android/tools/r8/graph/invokevirtual/InvokeVirtualPrivateBaseWithDefaultDirectInvokeTest.java
index f989728..a8a222d 100644
--- a/src/test/java/com/android/tools/r8/graph/invokevirtual/InvokeVirtualPrivateBaseWithDefaultDirectInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokevirtual/InvokeVirtualPrivateBaseWithDefaultDirectInvokeTest.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.utils.AndroidApiLevel;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -38,10 +37,7 @@
testForJvm()
.addInnerClasses(getClass())
.run(parameters.getRuntime(), Main.class)
- .applyIf(
- parameters.isCfRuntime(CfVm.JDK11),
- r -> r.assertSuccessWithOutputLines("I::foo"),
- r -> r.assertFailureWithErrorThatThrows(IllegalAccessError.class));
+ .apply(r -> assertResultIsCorrect(r, true));
}
@Test
@@ -50,7 +46,7 @@
.addInnerClasses(getClass())
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
- .apply(this::assertResultIsCorrect);
+ .apply(r -> assertResultIsCorrect(r, false));
}
@Test
@@ -63,17 +59,23 @@
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
// TODO(b/182189123): This should have the same behavior as D8.
- .assertSuccessWithOutputLines("I::foo");
+ .applyIf(
+ parameters.isCfRuntime(),
+ r -> r.assertSuccessWithOutputLines("I::foo"),
+ r -> assertResultIsCorrect(r, true));
}
- public void assertResultIsCorrect(SingleTestRunResult<?> result) {
- if (parameters.isCfRuntime(CfVm.JDK11)
- && parameters.getApiLevel().isGreaterThan(AndroidApiLevel.M)) {
+ public void assertResultIsCorrect(SingleTestRunResult<?> result, boolean nonDesugaredCf) {
+ boolean isNotDesugared =
+ (nonDesugaredCf && parameters.isCfRuntime())
+ || parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring();
+ // JDK 11 allows this incorrect dispatch for some reason.
+ if (parameters.isCfRuntime(CfVm.JDK11) && isNotDesugared) {
result.assertSuccessWithOutputLines("I::foo");
return;
}
- // TODO(b/152199517): Should be illegal access for DEX.
- if (parameters.isDexRuntime() && parameters.getApiLevel().isGreaterThan(AndroidApiLevel.M)) {
+ // TODO(b/152199517): Should become an illegal access on future DEX VM.
+ if (parameters.isDexRuntime() && isNotDesugared) {
result.assertSuccessWithOutputLines("I::foo");
return;
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index fd13bbf..b60f6c9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -125,7 +125,7 @@
// Tests depend on nullability of receiver and argument in general. Learning very
// accurate
// nullability from actual usage in tests bothers what we want to test.
- o.callSiteOptimizationOptions().disableTypePropagationForTesting();
+ o.callSiteOptimizationOptions().disableDynamicTypePropagationForTesting();
o.testing.horizontallyMergedClassesConsumer = this::fixInliningNullabilityClass;
o.testing.horizontalClassMergingTarget =
(appView, candidates, target) -> {
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 a36a63c..509465b 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
@@ -6,24 +6,30 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.utils.BooleanUtils;
+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 HashCodeTest extends TestBase {
+
private static final Class<?> MAIN = TestClass.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public HashCodeTest(TestParameters parameters) {
+ public HashCodeTest(boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -36,6 +42,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 b53f23c..2bf775f 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
@@ -14,29 +14,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfaceWithRefinedReceiverTest extends TestBase {
+
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfaceWithRefinedReceiverTest(TestParameters parameters) {
+ public InvokeInterfaceWithRefinedReceiverTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -55,6 +62,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 3ac7e29..2556bf4 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
@@ -14,29 +14,35 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualWithRefinedReceiverTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualWithRefinedReceiverTest(TestParameters parameters) {
+ public InvokeVirtualWithRefinedReceiverTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -52,6 +58,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 429b5a2..0c04377 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
@@ -9,7 +9,8 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -18,14 +19,18 @@
@RunWith(Parameterized.class)
public class PropagationFromSiblingTest extends TestBase {
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- @Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
- public PropagationFromSiblingTest(TestParameters parameters) {
+ public PropagationFromSiblingTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -34,7 +39,13 @@
testForR8(parameters.getBackend())
.addInnerClasses(PropagationFromSiblingTest.class)
.addKeepMainRule(TestClass.class)
- .addOptionsModification(options -> options.enableUnusedInterfaceRemoval = false)
+ .addOptionsModification(
+ options -> {
+ options.enableUnusedInterfaceRemoval = false;
+ options
+ .callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
+ })
.enableInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
index 04cbc5f..3c7307c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
@@ -13,28 +13,35 @@
import com.android.tools.r8.NoHorizontalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 WithStaticizerTest extends TestBase {
+
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
// TODO(b/112831361): support for class staticizer in CF backend.
- return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withDexRuntimes().withAllApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public WithStaticizerTest(TestParameters parameters) {
+ public WithStaticizerTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -43,6 +50,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(WithStaticizerTest.class)
.addKeepMainRule(MAIN)
+ .addOptionsModification(
+ options ->
+ options
+ .callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(
+ enableExperimentalArgumentPropagation))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
@@ -62,8 +75,12 @@
assertThat(host, isPresent());
MethodSubject foo = host.uniqueMethodWithName("foo");
assertThat(foo, isPresent());
- // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
- assertTrue(foo.streamInstructions().anyMatch(InstructionSubject::isIf));
+ if (enableExperimentalArgumentPropagation) {
+ assertTrue(foo.streamInstructions().noneMatch(InstructionSubject::isIf));
+ } else {
+ // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
+ assertTrue(foo.streamInstructions().anyMatch(InstructionSubject::isIf));
+ }
}
@NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
index 2e76fa2..3716b6d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectNegativeTest.java
@@ -11,30 +11,36 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectNegativeTest(TestParameters parameters) {
+ public InvokeDirectNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -48,6 +54,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
index e3fa7d7..4b220b6 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeDirectPositiveTest.java
@@ -11,32 +11,38 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectPositiveTest(TestParameters parameters) {
+ public InvokeDirectPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.addOptionsModification(InternalOptions::enableConstantArgumentPropagationForTesting)
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 7c2eeee..896d548 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfaceNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfaceNegativeTest(TestParameters parameters) {
+ public InvokeInterfaceNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -53,6 +59,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
index 93594ff..553ee4b 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeInterfacePositiveTest.java
@@ -12,32 +12,38 @@
import com.android.tools.r8.NoHorizontalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfacePositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfacePositiveTest(TestParameters parameters) {
+ public InvokeInterfacePositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -56,6 +62,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
index df1fb98..8457c5c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticNegativeTest.java
@@ -10,30 +10,36 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticNegativeTest(TestParameters parameters) {
+ public InvokeStaticNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -43,9 +49,12 @@
.addInnerClasses(InvokeStaticNegativeTest.class)
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("null", "non-null")
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
index 096362a..fe38d71 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/constants/InvokeStaticPositiveTest.java
@@ -10,32 +10,38 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticPositiveTest(TestParameters parameters) {
+ public InvokeStaticPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -48,6 +54,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.addOptionsModification(InternalOptions::enableConstantArgumentPropagationForTesting)
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 7be71b2..7464d26 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualNegativeTest(TestParameters parameters) {
+ public InvokeVirtualNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 e254dc6..9853a4c 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
@@ -12,31 +12,37 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualPositiveTest(TestParameters parameters) {
+ public InvokeVirtualPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -51,6 +57,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.addOptionsModification(InternalOptions::enableConstantArgumentPropagationForTesting)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
index 0cc9bb1..4a6d03d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeDirectNegativeTest.java
@@ -11,30 +11,36 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectNegativeTest(TestParameters parameters) {
+ public InvokeDirectNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -48,6 +54,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 51175f8..d23ed49 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectPositiveTest(TestParameters parameters) {
+ public InvokeDirectPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 31e6779..20b0d1f 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfaceNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfaceNegativeTest(TestParameters parameters) {
+ public InvokeInterfaceNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -53,6 +59,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 5a06d91..b39540b 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
@@ -13,30 +13,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfacePositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfacePositiveTest(TestParameters parameters) {
+ public InvokeInterfacePositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -55,6 +61,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
index 3c94778..6ae9004 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/dynamicupperboundtype/InvokeStaticNegativeTest.java
@@ -10,30 +10,36 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticNegativeTest(TestParameters parameters) {
+ public InvokeStaticNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -43,9 +49,12 @@
.addInnerClasses(InvokeStaticNegativeTest.class)
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("Sub1", "Sub2")
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 ff19f58..410d528 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
@@ -11,30 +11,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticPositiveTest(TestParameters parameters) {
+ public InvokeStaticPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -48,6 +54,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 39bfa4c..1db7baa 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualNegativeTest(TestParameters parameters) {
+ public InvokeVirtualNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 2595df5..adce8cc 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualPositiveTest(TestParameters parameters) {
+ public InvokeVirtualPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
index 96614da..05d1329 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectNegativeTest.java
@@ -11,28 +11,34 @@
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.graph.ProgramMethod;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectNegativeTest(TestParameters parameters) {
+ public InvokeDirectNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -46,6 +52,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
index 0b7ff7d..3a6fd02 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeDirectPositiveTest.java
@@ -11,29 +11,35 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeDirectPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeDirectPositiveTest(TestParameters parameters) {
+ public InvokeDirectPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -47,6 +53,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 bc9f10c..421ebf0 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfaceNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfaceNegativeTest(TestParameters parameters) {
+ public InvokeInterfaceNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -53,6 +59,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
index 19fa2a1..6d0aab9 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeInterfacePositiveTest.java
@@ -12,29 +12,35 @@
import com.android.tools.r8.NoHorizontalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeInterfacePositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeInterfacePositiveTest(TestParameters parameters) {
+ public InvokeInterfacePositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -52,6 +58,8 @@
// target.
o.enableDevirtualization = false;
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
index 0a18b69..a7fff40 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticNegativeTest.java
@@ -10,28 +10,34 @@
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.graph.ProgramMethod;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticNegativeTest(TestParameters parameters) {
+ public InvokeStaticNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -41,9 +47,12 @@
.addInnerClasses(InvokeStaticNegativeTest.class)
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("null", "non-null")
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
index 700ec34..0b27105 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/InvokeStaticPositiveTest.java
@@ -10,29 +10,35 @@
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.graph.ProgramMethod;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeStaticPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeStaticPositiveTest(TestParameters parameters) {
+ public InvokeStaticPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -42,9 +48,12 @@
.addInnerClasses(InvokeStaticPositiveTest.class)
.addKeepMainRule(MAIN)
.enableInliningAnnotations()
- .addOptionsModification(o -> {
- o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
- })
+ .addOptionsModification(
+ o -> {
+ o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
+ })
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines("non-null")
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 f46869d..627171a 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
@@ -12,27 +12,33 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualCascadeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualCascadeTest(TestParameters parameters) {
+ public InvokeVirtualCascadeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -41,6 +47,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(InvokeVirtualCascadeTest.class)
.addKeepMainRule(MAIN)
+ .addOptionsModification(
+ options ->
+ options
+ .callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(
+ enableExperimentalArgumentPropagation))
.enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
@@ -56,16 +68,24 @@
MethodSubject a_m = a.uniqueMethodWithName("m");
assertThat(a_m, isPresent());
- // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
- assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
+ if (enableExperimentalArgumentPropagation) {
+ assertTrue(a_m.streamInstructions().noneMatch(InstructionSubject::isIf));
+ } else {
+ // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
+ assertTrue(a_m.streamInstructions().anyMatch(InstructionSubject::isIf));
+ }
ClassSubject b = inspector.clazz(B.class);
assertThat(b, isPresent());
MethodSubject b_m = b.uniqueMethodWithName("m");
assertThat(b_m, isPresent());
- // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
- assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
+ if (enableExperimentalArgumentPropagation) {
+ assertTrue(b_m.streamInstructions().noneMatch(InstructionSubject::isIf));
+ } else {
+ // TODO(b/139246447): Can optimize branches since `arg` is definitely not null.
+ assertTrue(b_m.streamInstructions().anyMatch(InstructionSubject::isIf));
+ }
}
@NoVerticalClassMerging
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 544cf86..b9b1f2f 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualNegativeTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualNegativeTest(TestParameters parameters) {
+ public InvokeVirtualNegativeTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 2cff135..8e1031a 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
@@ -12,30 +12,36 @@
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.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 InvokeVirtualPositiveTest extends TestBase {
private static final Class<?> MAIN = Main.class;
- @Parameterized.Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimesAndApiLevels().build();
+ @Parameters(name = "{1}, experimental: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
+ private final boolean enableExperimentalArgumentPropagation;
private final TestParameters parameters;
- public InvokeVirtualPositiveTest(TestParameters parameters) {
+ public InvokeVirtualPositiveTest(
+ boolean enableExperimentalArgumentPropagation, TestParameters parameters) {
+ this.enableExperimentalArgumentPropagation = enableExperimentalArgumentPropagation;
this.parameters = parameters;
}
@@ -50,6 +56,8 @@
.addOptionsModification(
o -> {
o.testing.callSiteOptimizationInfoInspector = this::callSiteOptimizationInfoInspect;
+ o.callSiteOptimizationOptions()
+ .setEnableExperimentalArgumentPropagation(enableExperimentalArgumentPropagation);
})
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), MAIN)
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 46727f2..75679e5 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
@@ -9,16 +9,19 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ir.optimize.inliner.testclasses.InliningIntoVisibilityBridgeTestClasses;
import com.android.tools.r8.ir.optimize.inliner.testclasses.InliningIntoVisibilityBridgeTestClasses.InliningIntoVisibilityBridgeTestClassB;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -28,14 +31,17 @@
@RunWith(Parameterized.class)
public class InliningIntoVisibilityBridgeTest extends TestBase {
+ private final TestParameters parameters;
private final boolean neverInline;
- @Parameters(name = "Never inline: {0}")
- public static Boolean[] data() {
- return BooleanUtils.values();
+ @Parameters(name = "{0}, never inline: {1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
}
- public InliningIntoVisibilityBridgeTest(boolean neverInline) {
+ public InliningIntoVisibilityBridgeTest(TestParameters parameters, boolean neverInline) {
+ this.parameters = parameters;
this.neverInline = neverInline;
}
@@ -44,7 +50,7 @@
String expectedOutput = StringUtils.lines("Hello world", "Hello world", "Hello world");
R8TestRunResult result =
- testForR8(Backend.DEX)
+ testForR8(parameters.getBackend())
.addInnerClasses(InliningIntoVisibilityBridgeTest.class)
.addInnerClasses(InliningIntoVisibilityBridgeTestClasses.class)
.addKeepMainRule(TestClass.class)
@@ -54,8 +60,9 @@
.applyIf(!neverInline, R8TestBuilder::enableForceInliningAnnotations)
.enableNoVerticalClassMergingAnnotations()
.enableProguardTestOptions()
+ .setMinApi(parameters.getApiLevel())
.compile()
- .run(TestClass.class)
+ .run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(expectedOutput);
// Verify that A.method() is only there if there is an explicit -neverinline rule.
@@ -75,9 +82,11 @@
assertThat(classSubject, isPresent());
MethodSubject methodSubject = classSubject.uniqueMethodWithName("method");
- assertThat(methodSubject, isPresentAndRenamed());
- assertEquals(neverInline, methodSubject.isBridge());
- assertEquals(neverInline, methodSubject.isSynthetic());
+ if (!neverInline) {
+ assertThat(methodSubject, isPresentAndRenamed());
+ assertFalse(methodSubject.isBridge());
+ assertFalse(methodSubject.isSynthetic());
+ }
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
index 9b3dd42..baf0868 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/OutlineFromDefaultInterfaceMethodTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.outliner;
import static com.android.tools.r8.references.Reference.methodFromMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -16,11 +17,9 @@
import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
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.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -65,25 +64,22 @@
}
private void inspect(CodeInspector inspector) {
- ClassSubject interfaceSubject;
- MethodSubject greetMethodSubject;
- if (parameters.isCfRuntime()
- || parameters
- .getApiLevel()
- .isGreaterThanOrEqualTo(apiLevelWithDefaultInterfaceMethodsSupport())) {
- interfaceSubject = inspector.clazz(I.class);
- greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ ClassSubject interfaceSubject = inspector.clazz(I.class);
+ MethodSubject greetMethodSubject = interfaceSubject.uniqueMethodWithName("greet");
+ assertThat(interfaceSubject, isPresent());
+ assertThat(greetMethodSubject, isPresent());
+ assertEquals(
+ 1,
+ greetMethodSubject
+ .streamInstructions()
+ .filter(InstructionSubject::isInvokeStatic)
+ .count());
} else {
- interfaceSubject = inspector.clazz(SyntheticItemsTestUtils.syntheticCompanionClass(I.class));
- List<FoundMethodSubject> companionMethods = interfaceSubject.allMethods();
- assertEquals(1, companionMethods.size());
- greetMethodSubject = companionMethods.get(0);
+ // The companion class method is inlined into main.
+ assertThat(
+ inspector.clazz(SyntheticItemsTestUtils.syntheticCompanionClass(I.class)), isAbsent());
}
- assertThat(interfaceSubject, isPresent());
- assertThat(greetMethodSubject, isPresent());
- assertEquals(
- 1,
- greetMethodSubject.streamInstructions().filter(InstructionSubject::isInvokeStatic).count());
}
static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
index d1d5f1f..000f5d4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetClassTest.java
@@ -155,7 +155,7 @@
// In `getMainClass`, a call with `null`, which will throw NPE, is replaced with null throwing
// code. Then, remaining call with non-null argument made getClass() replaceable.
// Disable the propagation of call site information to separate the tests.
- options.callSiteOptimizationOptions().disableTypePropagationForTesting();
+ options.callSiteOptimizationOptions().disableDynamicTypePropagationForTesting();
}
@Test
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
index 2e1709c..01ac9dc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
@@ -58,7 +58,7 @@
// Disable the propagation of call site information to test String#valueOf optimization with
// nullable argument. Otherwise, e.g., we know that only `null` is used for `hideNPE`, and then
// simplify everything in that method.
- options.callSiteOptimizationOptions().disableTypePropagationForTesting();
+ options.callSiteOptimizationOptions().disableDynamicTypePropagationForTesting();
options.testing.forceNameReflectionOptimization = true;
}
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 6bc0862..c10d1db 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
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.unusedinterfaces;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -57,7 +58,9 @@
assertThat(iClassSubject, isPresent());
ClassSubject jClassSubject = inspector.clazz(J.class);
- assertThat(jClassSubject, isPresent());
+ assertThat(
+ jClassSubject,
+ parameters.canUseDefaultAndStaticInterfaceMethods() ? isPresent() : isAbsent());
ClassSubject aClassSubject = inspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
@@ -66,7 +69,9 @@
// m() that happens to be used.
assertEquals(1, aClassSubject.getDexProgramClass().interfaces.size());
assertEquals(
- jClassSubject.getDexProgramClass().type,
+ parameters.canUseDefaultAndStaticInterfaceMethods()
+ ? jClassSubject.getDexProgramClass().type
+ : iClassSubject.getDexProgramClass().type,
aClassSubject.getDexProgramClass().interfaces.values[0]);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
index 717bf12..b175132 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
@@ -75,9 +75,6 @@
testForD8(Backend.DEX)
.addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(AndroidApiLevel.B)
- // Enable record desugaring support to force a non-identity naming lens
- .addOptionsModification(
- options -> options.testing.enableExperimentalRecordDesugaring = true)
.compile()
.inspect(
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 aa38f06..031440f 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingBridgeRemovalTest.java
@@ -29,7 +29,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public MemberRebindingBridgeRemovalTest(TestParameters parameters) {
@@ -44,7 +44,7 @@
.addKeepMainRule(TestClass.class)
.enableInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java
new file mode 100644
index 0000000..d569899
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java
@@ -0,0 +1,106 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isSynthetic;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+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 MemberRebindingRemoveInterfaceBridgeTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveInterfaceBridgeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class, I.class, J.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .addKeepClassAndMembersRules(I.class)
+ .enableInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("A::foo")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(J.class);
+ assertThat(clazz, isPresent());
+ // TODO(b/197490164): We should remove the bridge inserted here.
+ assertEquals(1, clazz.allMethods().size());
+ FoundMethodSubject foundMethodSubject = clazz.allMethods().get(0);
+ assertThat(foundMethodSubject, isSynthetic());
+ });
+ }
+
+ interface I {
+
+ void foo();
+ }
+
+ public interface J extends I {}
+
+ @NoHorizontalClassMerging
+ public static class A implements J {
+
+ @Override
+ @NeverInline
+ public void foo() {
+ System.out.println("A::foo");
+ }
+ }
+
+ @NoHorizontalClassMerging
+ public static class B implements J {
+
+ @Override
+ @NeverInline
+ public void foo() {
+ System.out.println("B::foo");
+ }
+ }
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ callJ(args.length == 0 ? new A() : new B());
+ }
+
+ @NeverInline
+ private static void callJ(J j) {
+ j.foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java
new file mode 100644
index 0000000..f1fc86d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java
@@ -0,0 +1,101 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isSynthetic;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+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 MemberRebindingRemoveInterfaceBridgeWithSubTypeTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveInterfaceBridgeWithSubTypeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class, I.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .addKeepClassAndMembersRules(I.class)
+ .enableInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .noMinification()
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("B::foo")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(A.class);
+ assertThat(clazz, isPresent());
+ // TODO(b/197490164): We should remove the bridge inserted here.
+ assertEquals(1, clazz.virtualMethods().size());
+ FoundMethodSubject foundMethodSubject = clazz.virtualMethods().get(0);
+ assertThat(foundMethodSubject, isSynthetic());
+ });
+ }
+
+ interface I {
+
+ void foo();
+ }
+
+ @NoHorizontalClassMerging
+ @NoVerticalClassMerging
+ public abstract static class A implements I {}
+
+ @NoHorizontalClassMerging
+ public static class B extends A {
+
+ @Override
+ @NeverInline
+ public void foo() {
+ System.out.println("B::foo");
+ }
+ }
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ callJ(args.length == 0 ? new B() : null);
+ }
+
+ @NeverInline
+ private static void callJ(A a) {
+ a.foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceDefaultBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceDefaultBridgeTest.java
new file mode 100644
index 0000000..e11bdfe
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceDefaultBridgeTest.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MemberRebindingRemoveInterfaceDefaultBridgeTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveInterfaceDefaultBridgeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, I.class, J.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .addKeepClassAndMembersRules(I.class)
+ .enableInliningAnnotations()
+ .enableNoHorizontalClassMergingAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("I::foo")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(J.class);
+ assertThat(clazz, isPresent());
+ assertTrue(clazz.allMethods().isEmpty());
+ if (!parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ ClassSubject classSubject = clazz.toCompanionClass();
+ assertThat(classSubject, isAbsent());
+ }
+ });
+ }
+
+ interface I {
+
+ @NeverInline
+ default void foo() {
+ System.out.println("I::foo");
+ }
+ }
+
+ @NoVerticalClassMerging
+ public interface J extends I {}
+
+ @NoHorizontalClassMerging
+ public static class A implements J {}
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ callJ(args.length == 0 ? new A() : null);
+ }
+
+ @NeverInline
+ private static void callJ(J j) {
+ j.foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveStaticBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveStaticBridgeTest.java
new file mode 100644
index 0000000..8bdaa09
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveStaticBridgeTest.java
@@ -0,0 +1,79 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+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 MemberRebindingRemoveStaticBridgeTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveStaticBridgeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .enableInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(B.class);
+ assertThat(clazz, isPresent());
+ assertTrue(clazz.allMethods().isEmpty());
+ });
+ }
+
+ @NoVerticalClassMerging
+ static class A {
+
+ @NeverInline
+ public static void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class B extends A {}
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ B.foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeDontShrinkTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeDontShrinkTest.java
new file mode 100644
index 0000000..c23c295
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeDontShrinkTest.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+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.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+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 MemberRebindingRemoveVirtualBridgeDontShrinkTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveVirtualBridgeDontShrinkTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .enableInliningAnnotations()
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addDontShrink()
+ .addDontOptimize()
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(B.class);
+ assertThat(clazz, isPresent());
+ // TODO(b/197491051): We should be able to remove bridges we have inserted.
+ assertFalse(clazz.allMethods(FoundMethodSubject::isBridge).isEmpty());
+ });
+ }
+
+ static class A {
+
+ @NeverInline
+ public void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class B extends A {}
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ new B().foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java
new file mode 100644
index 0000000..f38e042
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.memberrebinding;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isInstanceInitializer;
+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.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+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 MemberRebindingRemoveVirtualBridgeTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final String newMainDescriptor = "La/Main;";
+ private final String newMainTypeName = DescriptorUtils.descriptorToJavaType(newMainDescriptor);
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public MemberRebindingRemoveVirtualBridgeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class)
+ .addProgramClassFileData(
+ transformer(Main.class).setClassDescriptor(newMainDescriptor).transform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(newMainTypeName)
+ .enableInliningAnnotations()
+ .enableNoVerticalClassMergingAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .run(parameters.getRuntime(), newMainTypeName)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(B.class);
+ assertThat(clazz, isPresent());
+ assertEquals(1, clazz.allMethods().size());
+ FoundMethodSubject foundMethodSubject = clazz.allMethods().get(0);
+ assertThat(foundMethodSubject, isInstanceInitializer());
+ });
+ }
+
+ @NoVerticalClassMerging
+ static class A {
+
+ @NeverInline
+ public void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ @NeverClassInline
+ public static class B extends A {}
+
+ public static class /* a.Main */ Main {
+
+ public static void main(String[] args) {
+ new B().foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
index 1868602..18f0c96 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
@@ -3,16 +3,15 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming.applymapping.desugar;
-import static com.android.tools.r8.references.Reference.classFromClass;
-import static org.junit.Assert.assertTrue;
+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.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringForTesting;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -73,26 +72,21 @@
@Test
public void testLibraryLinkedWithProgram() throws Throwable {
- String ruleContent = "-keep class " + LibraryInterface.class.getTypeName() + " { *; }";
R8TestCompileResult libraryResult =
testForR8(parameters.getBackend())
.addProgramClasses(LibraryInterface.class)
- .addKeepRules(ruleContent)
+ .addKeepClassAndMembersRules(LibraryInterface.class)
.setMinApi(parameters.getApiLevel())
.compile();
CodeInspector inspector = libraryResult.inspector();
- assertTrue(inspector.clazz(LibraryInterface.class).isPresent());
- assertTrue(inspector.method(LibraryInterface.class.getMethod("foo")).isPresent());
- if (willDesugarDefaultInterfaceMethods(parameters.getApiLevel())) {
+ assertThat(inspector.clazz(LibraryInterface.class), isPresent());
+ assertThat(inspector.method(LibraryInterface.class.getMethod("foo")), isPresent());
+ if (!parameters.canUseDefaultAndStaticInterfaceMethods()) {
ClassSubject companion =
- inspector.clazz(
- Reference.classFromDescriptor(
- InterfaceDesugaringForTesting.getCompanionClassDescriptor(
- classFromClass(LibraryInterface.class).getDescriptor())));
- // Check that we included the companion class.
- assertTrue(companion.isPresent());
- // TODO(b/129223905): Check the method is also present on the companion class.
- assertTrue(inspector.method(LibraryInterface.class.getMethod("foo")).isPresent());
+ inspector.clazz(SyntheticItemsTestUtils.syntheticCompanionClass(LibraryInterface.class));
+ // Check that we included the companion class and method.
+ assertThat(companion, isPresent());
+ assertEquals(1, companion.allMethods().size());
}
testForR8(parameters.getBackend())
@@ -107,8 +101,4 @@
.run(parameters.getRuntime(), ProgramClass.class)
.assertSuccessWithOutput(EXPECTED);
}
-
- private static boolean willDesugarDefaultInterfaceMethods(AndroidApiLevel apiLevel) {
- return apiLevel != null && apiLevel.getLevel() < AndroidApiLevel.N.getLevel();
- }
}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java
new file mode 100644
index 0000000..1dfd029
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java
@@ -0,0 +1,110 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.naming.applymapping.desugar;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// Reproduction for b/196345511.
+@RunWith(Parameterized.class)
+public class StaticInterfaceMethodTest extends TestBase {
+
+ public static final String OUTPUT = "Called LibraryInterface::foo";
+ public static final String EXPECTED = StringUtils.lines(OUTPUT);
+
+ public interface LibraryInterface {
+ static void foo() {
+ System.out.println(OUTPUT);
+ }
+ }
+
+ public static class ProgramClass implements LibraryInterface {
+
+ public static void main(String[] args) {
+ LibraryInterface.foo();
+ }
+ }
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection params() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ private final TestParameters parameters;
+
+ public StaticInterfaceMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testJvm() throws Throwable {
+ Assume.assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClasses(LibraryInterface.class, ProgramClass.class)
+ .run(parameters.getRuntime(), ProgramClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testFullProgram() throws Throwable {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(LibraryInterface.class, ProgramClass.class)
+ .addKeepMainRule(ProgramClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), ProgramClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testLibraryLinkedWithProgram() throws Throwable {
+ R8TestCompileResult libraryResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(LibraryInterface.class)
+ .addKeepClassAndMembersRules(LibraryInterface.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+ CodeInspector inspector = libraryResult.inspector();
+ ClassSubject libraryInterface = inspector.clazz(LibraryInterface.class);
+ assertThat(libraryInterface, isPresent());
+ if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+ assertThat(libraryInterface.method(LibraryInterface.class.getMethod("foo")), isPresent());
+ } else {
+ // Desugaring must remove the static on the interface.
+ assertThat(libraryInterface.method(LibraryInterface.class.getMethod("foo")), isAbsent());
+ // Check that we included the companion class and method.
+ ClassSubject companion =
+ inspector.clazz(SyntheticItemsTestUtils.syntheticCompanionClass(LibraryInterface.class));
+ assertThat(companion, isPresent());
+ assertEquals(1, companion.allMethods().size());
+ }
+
+ testForR8(parameters.getBackend())
+ .noTreeShaking()
+ .addProgramClasses(ProgramClass.class)
+ .addClasspathClasses(LibraryInterface.class)
+ .addApplyMapping(libraryResult.getProguardMap())
+ .addKeepMainRule(ProgramClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .addRunClasspathFiles(libraryResult.writeToZip())
+ .run(parameters.getRuntime(), ProgramClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/DefaultMethodShadowedByStaticTest.java b/src/test/java/com/android/tools/r8/resolution/DefaultMethodShadowedByStaticTest.java
index 19424d8..b974111 100644
--- a/src/test/java/com/android/tools/r8/resolution/DefaultMethodShadowedByStaticTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/DefaultMethodShadowedByStaticTest.java
@@ -6,7 +6,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.resolution.shadowing1.AClassDump;
import com.android.tools.r8.resolution.shadowing1.InterfaceDump;
@@ -39,22 +38,15 @@
@Test
public void testReference() throws Exception {
- TestRunResult<?> result =
- testForRuntime(parameters)
- .addProgramClassFileData(CLASSES)
- .run(parameters.getRuntime(), "Main");
- if (parameters.isDexRuntime()
- && (parameters.getApiLevel().isLessThan(apiLevelWithStaticInterfaceMethodsSupport())
- || parameters.getDexRuntimeVersion().equals(Version.V7_0_0))) {
- // TODO(b/167535447): Desugaring should preserve the error.
- result.assertSuccessWithOutputLines("42");
- } else if (parameters.isDexRuntime()
- && parameters.getDexRuntimeVersion().equals(Version.V7_0_0)) {
- // Note: VM 7.0.0 without desugaring of defaults will incorrectly allow the virtual dispatch.
- result.assertSuccessWithOutputLines("42");
- } else {
- result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
- }
+ testForRuntime(parameters)
+ .addProgramClassFileData(CLASSES)
+ .run(parameters.getRuntime(), "Main")
+ .applyIf(
+ // When not desugaring interfaces, the v7 runtime fails to throw the correct error.
+ parameters.canUseDefaultAndStaticInterfaceMethods()
+ && parameters.isDexRuntimeVersion(Version.V7_0_0),
+ r -> r.assertSuccessWithOutputLines("42"),
+ r -> r.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
index b176930..7d18aee 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
@@ -8,6 +8,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.AsmTestBase;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
@@ -89,12 +90,17 @@
@BeforeClass
public static void computeAppInfo() throws Exception {
appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(CLASSES)
- .addClassProgramData(ASM_CLASSES)
- .addLibraryFile(getMostRecentAndroidJar())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addAndroidApp(
+ buildClassesWithTestingAnnotations(CLASSES)
+ .addClassProgramData(ASM_CLASSES)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build())
+ .addKeepMainRule(Main.class)
+ // Some of these tests resolve default methods.
+ // If desugared they will hit the forward methods and not the expected defaults.
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
appInfo = appView.appInfo();
}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
index cbad874..846c994 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
@@ -4,22 +4,18 @@
package com.android.tools.r8.resolution;
import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import com.android.tools.r8.AsmTestBase;
-import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.MethodResolutionResult;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Assert;
@@ -150,22 +146,11 @@
@Test
public void runJvmAndD8() throws Exception {
- TestRunResult<?> runResult;
- if (parameters.isCfRuntime()) {
- runResult =
- testForJvm()
- .addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMP)
- .run(parameters.getRuntime(), Main.class);
- } else {
- runResult =
- testForD8()
- .addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMP)
- .setMinApi(parameters.getApiLevel())
- .run(parameters.getRuntime(), Main.class);
- }
- checkResult(runResult);
+ testForRuntime(parameters)
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(DUMP)
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
@Test
@@ -179,33 +164,13 @@
}
public void runR8(boolean enableVerticalClassMerging) throws Exception {
- R8TestRunResult runResult =
- testForR8(parameters.getBackend())
- .addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMP)
- .addKeepMainRule(Main.class)
- .setMinApi(parameters.getApiLevel())
- .addOptionsModification(o -> o.enableVerticalClassMerging = enableVerticalClassMerging)
- .run(parameters.getRuntime(), Main.class);
- if (enableVerticalClassMerging) {
- // Vertical class merging will merge B and C and change the instruction to invoke-virtual
- // causing the legacy ART runtime behavior to match the expected error.
- runResult.assertFailureWithErrorThatMatches(containsString("IncompatibleClassChangeError"));
- } else {
- checkResult(runResult);
- }
- }
-
- private void checkResult(TestRunResult<?> runResult) {
- runResult.assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
- }
-
- private String expectedRuntimeError() {
- if (parameters.isDexRuntime()
- && parameters.getApiLevel().getLevel() < AndroidApiLevel.N.getLevel()) {
- // When desugaring default interface methods the error will be NoSuchMethodError.
- return "NoSuchMethodError";
- }
- return "IncompatibleClassChangeError";
+ testForR8(parameters.getBackend())
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(DUMP)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .addOptionsModification(o -> o.enableVerticalClassMerging = enableVerticalClassMerging)
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
index c6e9206..ca29588 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.resolution;
import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -13,8 +12,7 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRunResult;
-import com.android.tools.r8.TestRuntime;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
@@ -226,23 +224,18 @@
}
private void checkResult(TestRunResult<?> runResult, boolean isCorrectedByR8) {
- if (expectedToIncorrectlyRun(parameters.getRuntime(), isCorrectedByR8)) {
- // Do to incorrect resolution, some Art VMs will resolve to Base.f (ignoring A.f) and thus
+ if (expectedToIncorrectlyRun(isCorrectedByR8)) {
+ // Do to incorrect resolution, some Art 7 will resolve to Base.f (ignoring A.f) and thus
// virtual dispatch to C.f. See b/140013075.
runResult.assertSuccessWithOutputLines("Called C.f");
} else {
- runResult.assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+ runResult.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
}
- private boolean expectedToIncorrectlyRun(TestRuntime runtime, boolean isCorrectedByR8) {
+ private boolean expectedToIncorrectlyRun(boolean isCorrectedByR8) {
return !isCorrectedByR8
- && runtime.isDex()
- && runtime.asDex().getVm().isNewerThan(DexVm.ART_4_4_4_HOST)
- && runtime.asDex().getVm().isOlderThanOrEqual(DexVm.ART_7_0_0_HOST);
- }
-
- private static String expectedRuntimeError() {
- return "IncompatibleClassChangeError";
+ && parameters.canUseDefaultAndStaticInterfaceMethods()
+ && parameters.isDexRuntimeVersion(Version.V7_0_0);
}
}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
index 4787b97..82c6b63 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialInterfaceMethodAccessWithIntermediateTest.java
@@ -10,6 +10,7 @@
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
@@ -20,6 +21,7 @@
import com.android.tools.r8.graph.MethodResolutionResult.NoSuchMethodResult;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -52,6 +54,7 @@
.withCfRuntimesStartingFromIncluding(JDK11)
.withDexRuntimes()
.withAllApiLevels()
+ .enableApiLevelsForCf()
.build(),
BooleanUtils.values(),
BooleanUtils.values());
@@ -132,7 +135,16 @@
MethodSubject foo = inspector.clazz(callerClass).uniqueMethodWithName("foo");
assertTrue(
foo.streamInstructions()
- .anyMatch(i -> i.asCfInstruction().isInvokeSpecial() && i.getMethod() == method));
+ .anyMatch(
+ i -> {
+ if (parameters.canUseDefaultAndStaticInterfaceMethodsWhenDesugaring()) {
+ return i.asCfInstruction().isInvokeSpecial() && i.getMethod() == method;
+ } else {
+ return i.isInvokeStatic()
+ && SyntheticItemsTestUtils.isInternalThrowNSME(
+ i.getMethod().asMethodReference());
+ }
+ }));
}
private DexMethod getTargetMethodSignature(Class<?> declaredClass, AppInfoWithLiveness appInfo) {
@@ -148,12 +160,13 @@
}
private AppView<AppInfoWithLiveness> getAppView() throws Exception {
- return computeAppViewWithLiveness(
- buildClasses(getClasses())
- .addClassProgramData(getTransformedClasses())
- .addLibraryFile(TestBase.runtimeJar(parameters.getBackend()))
- .build(),
- Main.class);
+ return TestAppViewBuilder.builder()
+ .addProgramClasses(getClasses())
+ .addProgramClassFileData(getTransformedClasses())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .buildWithLiveness();
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
index d6edf4f..47d664f 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -15,7 +16,6 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.Collections;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -42,12 +42,13 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES)
- .addClassProgramData(Collections.singletonList(transformB()))
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class)
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(transformB())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness()
.appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
index 77fad9a..f6b2df5 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -15,7 +16,6 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.Collections;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -42,12 +42,13 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES)
- .addClassProgramData(Collections.singletonList(transformB()))
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class)
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(transformB())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness()
.appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
index 41307e8..af70288 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
@@ -7,6 +7,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -15,7 +16,6 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -44,12 +44,13 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES)
- .addClassProgramData(Collections.singletonList(transformB()))
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class)
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(transformB())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness()
.appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
index 9b9a45d..d2d08a5 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,9 +42,12 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES).addLibraryFile(parameters.getDefaultRuntimeLibrary()).build(),
- Main.class)
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness()
.appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
index 50dc8d8..1b900b4 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -41,9 +42,12 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES).addLibraryFile(parameters.getDefaultRuntimeLibrary()).build(),
- Main.class)
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness()
.appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
index 0139049..8901542 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
@@ -5,17 +5,19 @@
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.MethodResolutionResult;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -44,21 +46,45 @@
public void testResolution() throws Exception {
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
- AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(
- buildClasses(CLASSES)
- .addClassProgramData(Collections.singletonList(transformB()))
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class)
- .appInfo();
- DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
- MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
- Set<String> holders = new HashSet<>();
- resolutionResult
- .asFailedResolution()
- .forEachFailureDependency(m -> holders.add(m.getHolderType().toSourceString()));
- assertEquals(ImmutableSet.of(I.class.getTypeName(), J.class.getTypeName()), holders);
+ for (AndroidApiLevel minApi :
+ ImmutableList.of(AndroidApiLevel.B, apiLevelWithDefaultInterfaceMethodsSupport())) {
+ AppInfoWithLiveness appInfo =
+ TestAppViewBuilder.builder()
+ .addProgramClasses(CLASSES)
+ .addProgramClassFileData(transformB())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(minApi)
+ .buildWithLiveness()
+ .appInfo();
+ DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
+ MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
+ if (minApi.isLessThan(apiLevelWithDefaultInterfaceMethodsSupport())) {
+ // When desugaring a forwarding method throwing ICCE is inserted.
+ // Check that the resolved method throws such an exception.
+ assertTrue(
+ resolutionResult
+ .asSingleResolution()
+ .getResolvedMethod()
+ .getCode()
+ .asCfCode()
+ .getInstructions()
+ .stream()
+ .anyMatch(
+ i ->
+ i.isTypeInstruction()
+ && i.asTypeInstruction().getType()
+ == appInfo.dexItemFactory().icceType));
+ } else {
+ // When not desugaring resolution should fail. Check the failure dependencies are the two
+ // default methods in conflict.
+ Set<String> holders = new HashSet<>();
+ resolutionResult
+ .asFailedResolution()
+ .forEachFailureDependency(m -> holders.add(m.getHolderType().toSourceString()));
+ assertEquals(ImmutableSet.of(I.class.getTypeName(), J.class.getTypeName()), holders);
+ }
+ }
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
index f8a46ca..b3c88c7 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,11 +54,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addProgramClasses(I.class, J.class, A.class, Main.class)
+ .addTestingAnnotations()
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult =
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 4449400..1b3d3d9 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,11 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, A.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addTestingAnnotations()
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult =
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 6701adc..467ca50 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,12 +53,14 @@
public void testDynamicLookupTargets() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, Main.class)
- .addClassProgramData(setAImplementsIAndJ())
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addProgramClasses(I.class, J.class, Main.class)
+ .addTestingAnnotations()
+ .addProgramClassFileData(setAImplementsIAndJ())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
@@ -99,12 +102,14 @@
public void testDynamicLookupTargetsWithIndirectDefault() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, K.class, Main.class)
- .addClassProgramData(setAimplementsIandK())
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, K.class, Main.class)
+ .addProgramClassFileData(setAimplementsIandK())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
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 ae340f7..af2dde1 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,11 +54,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, A.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
index 0ec1ce8..4dcead3 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.resolution.interfacetargets;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assume.assumeTrue;
import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
@@ -17,7 +16,6 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.DescriptorUtils;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
@@ -70,7 +68,7 @@
.addProgramClasses(A.class, I.class)
.addProgramClassFileData(transformMain())
.run(parameters.getRuntime(), Main.class)
- .assertFailureWithErrorThatMatches(containsString(getExpected()));
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
@Test
@@ -81,14 +79,7 @@
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
- .assertFailureWithErrorThatMatches(containsString(getExpected()));
- }
-
- private String getExpected() {
- return parameters.isCfRuntime()
- || parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)
- ? "IncompatibleClassChangeError"
- : "NoSuchMethodError";
+ .assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
}
private byte[] transformMain() throws IOException {
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 9af861c..0819b97 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,11 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, A.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(J.class, "bar", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult =
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 512e775..4d85bfb 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,12 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(
- I.class, J.class, A.class, B.class, C.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult =
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
index fe3a74c..e59ea7a 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
@@ -10,6 +10,7 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -64,12 +65,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClasses(C.class, Main.class)
- .addClasspathFiles(classPathJar)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addProgramClasses(C.class, Main.class)
+ .addClasspathFiles(classPathJar)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(Abstract.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
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 f6368cb..d91d19f 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,11 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, A.class, B.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, A.class, B.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
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 4673e7c..69c8c7a 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,11 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, A.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
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 d6d5dc8..65d8316 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,12 +53,14 @@
public void testDynamicLookupTargets() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, J.class, Main.class)
- .addClassProgramData(setAImplementsIAndJ())
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, J.class, Main.class)
+ .addProgramClassFileData(setAImplementsIAndJ())
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
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 e6e6f6c..14f9d2a 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -52,11 +53,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(A.class, I.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(A.class, I.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
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 536f420..162d3c4 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
@@ -14,6 +14,7 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestAppViewBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -53,11 +54,13 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(
- buildClassesWithTestingAnnotations(I.class, A.class, B.class, C.class, Main.class)
- .addLibraryFile(parameters.getDefaultRuntimeLibrary())
- .build(),
- Main.class);
+ TestAppViewBuilder.builder()
+ .addTestingAnnotations()
+ .addProgramClasses(I.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
+ .addKeepMainRule(Main.class)
+ .setMinApi(apiLevelWithDefaultInterfaceMethodsSupport())
+ .buildWithLiveness();
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
MethodResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryCompatibilityTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryCompatibilityTest.java
new file mode 100644
index 0000000..df7c599
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryCompatibilityTest.java
@@ -0,0 +1,95 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.api;
+
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.ZipUtils;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RetraceApiBinaryCompatibilityTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ public RetraceApiBinaryCompatibilityTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private static final Path BINARY_COMPATIBILITY_JAR =
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, "retrace", "binary_compatibility", "tests.jar");
+
+ private Path generateJar() throws Exception {
+ return RetraceApiTestHelper.generateJarForRetraceBinaryTests(
+ temp, RetraceApiTestHelper.getBinaryCompatibilityTests());
+ }
+
+ @Test
+ public void testBinaryJarIsUpToDate() throws Exception {
+ Path binaryContents = temp.newFolder().toPath();
+ Path generatedContents = temp.newFolder().toPath();
+ ZipUtils.unzip(BINARY_COMPATIBILITY_JAR, binaryContents);
+ ZipUtils.unzip(generateJar(), generatedContents);
+ try (Stream<Path> existingPaths = Files.walk(binaryContents);
+ Stream<Path> generatedPaths = Files.walk(generatedContents)) {
+ List<Path> existing = existingPaths.filter(this::isClassFile).collect(Collectors.toList());
+ List<Path> generated = generatedPaths.filter(this::isClassFile).collect(Collectors.toList());
+ assertEquals(existing.size(), generated.size());
+ assertNotEquals(0, existing.size());
+ for (Path classFile : generated) {
+ Path otherClassFile = binaryContents.resolve(generatedContents.relativize(classFile));
+ assertTrue(Files.exists(otherClassFile));
+ assertTrue(TestBase.filesAreEqual(classFile, otherClassFile));
+ }
+ }
+ }
+
+ private boolean isClassFile(Path path) {
+ return path.toString().endsWith(".class");
+ }
+
+ @Test
+ public void runCheckedInBinaryJar() throws Exception {
+ for (CfRuntime cfRuntime : CfRuntime.getCheckedInCfRuntimes()) {
+ RetraceApiTestHelper.runJunitOnTests(
+ cfRuntime,
+ ToolHelper.R8_RETRACE_JAR,
+ BINARY_COMPATIBILITY_JAR,
+ RetraceApiTestHelper.getBinaryCompatibilityTests());
+ }
+ }
+
+ public static void main(String[] args) throws Exception {
+ TemporaryFolder temp = new TemporaryFolder();
+ temp.create();
+ Path generatedJar =
+ RetraceApiTestHelper.generateJarForRetraceBinaryTests(
+ temp, RetraceApiTestHelper.getBinaryCompatibilityTests());
+ Files.move(generatedJar, BINARY_COMPATIBILITY_JAR, REPLACE_EXISTING);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryTest.java
new file mode 100644
index 0000000..eac71c5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiBinaryTest.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.api;
+
+public interface RetraceApiBinaryTest {}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiEmptyTest.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiEmptyTest.java
new file mode 100644
index 0000000..45df95c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiEmptyTest.java
@@ -0,0 +1,51 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.api;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.retrace.ProguardMapProducer;
+import com.android.tools.r8.retrace.RetracedClassReference;
+import com.android.tools.r8.retrace.Retracer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RetraceApiEmptyTest extends RetraceApiTestBase {
+
+ public RetraceApiEmptyTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Override
+ protected Class<? extends RetraceApiBinaryTest> binaryTestClass() {
+ return RetraceTest.class;
+ }
+
+ public static class RetraceTest implements RetraceApiBinaryTest {
+
+ @Test
+ public void testNone() throws Exception {
+ String expected = "hello.World";
+ List<RetracedClassReference> retracedClasses = new ArrayList<>();
+ Retracer.createDefault(ProguardMapProducer.fromString(""), new DiagnosticsHandler() {})
+ .retraceClass(Reference.classFromTypeName(expected))
+ .stream()
+ .forEach(
+ result -> {
+ retracedClasses.add(result.getRetracedClass());
+ });
+ assertEquals(1, retracedClasses.size());
+ RetracedClassReference retracedClass = retracedClasses.get(0);
+ assertEquals(retracedClass.getTypeName(), expected);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestBase.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestBase.java
new file mode 100644
index 0000000..a58102a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestBase.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.api;
+
+import static com.android.tools.r8.retrace.api.RetraceApiTestHelper.runJunitOnTests;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersBuilder;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import java.nio.file.Files;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.Parameterized.Parameters;
+
+public abstract class RetraceApiTestBase extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return TestParametersBuilder.builder().withSystemRuntime().build();
+ }
+
+ public RetraceApiTestBase(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ protected abstract Class<? extends RetraceApiBinaryTest> binaryTestClass();
+
+ @Test
+ public void testDirect() {
+ Result result = JUnitCore.runClasses(binaryTestClass());
+ for (Failure failure : result.getFailures()) {
+ System.out.println(failure.toString());
+ }
+ assertTrue(result.wasSuccessful());
+ }
+
+ @Test
+ public void testRetraceLib() throws Exception {
+ Assume.assumeTrue(Files.exists(ToolHelper.R8_RETRACE_JAR));
+ runJunitOnTests(
+ parameters.getRuntime().asCf(), ToolHelper.R8_RETRACE_JAR, binaryTestClass(), temp);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestHelper.java b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestHelper.java
new file mode 100644
index 0000000..9b2f67d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/api/RetraceApiTestHelper.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace.api;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.Collectors;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.transformers.ClassFileTransformer;
+import com.android.tools.r8.transformers.ClassFileTransformer.InnerClassPredicate;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import com.google.common.collect.ImmutableList;
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.junit.rules.TemporaryFolder;
+
+public class RetraceApiTestHelper {
+
+ private static final String JUNIT_JAR = "junit-4.13-beta-2.jar";
+ private static final String HAMCREST = "hamcrest-core-1.3.jar";
+
+ public static List<Class<? extends RetraceApiBinaryTest>> CLASSES_FOR_BINARY_COMPATIBILITY =
+ ImmutableList.of(RetraceApiEmptyTest.RetraceTest.class);
+ public static List<Class<? extends RetraceApiBinaryTest>> CLASSES_PENDING_BINARY_COMPATIBILITY =
+ ImmutableList.of();
+
+ public static void runJunitOnTests(
+ CfRuntime runtime,
+ Path r8Jar,
+ Class<? extends RetraceApiBinaryTest> clazz,
+ TemporaryFolder temp)
+ throws Exception {
+ assertTrue(testIsSpecifiedAsBinaryOrPending(clazz));
+ List<Class<? extends RetraceApiBinaryTest>> testClasses = ImmutableList.of(clazz);
+ runJunitOnTests(
+ runtime, r8Jar, generateJarForRetraceBinaryTests(temp, testClasses), testClasses);
+ }
+
+ public static void runJunitOnTests(
+ CfRuntime runtime,
+ Path r8Jar,
+ Path testJar,
+ Collection<Class<? extends RetraceApiBinaryTest>> tests)
+ throws Exception {
+ List<Path> classPaths = ImmutableList.of(getJunitDependency(), getHamcrest(), r8Jar, testJar);
+ ProcessResult processResult =
+ ToolHelper.runJava(
+ runtime,
+ classPaths,
+ "org.junit.runner.JUnitCore",
+ StringUtils.join(" ", tests, Class::getTypeName));
+ assertEquals(0, processResult.exitCode);
+ assertThat(processResult.stdout, containsString("OK (" + tests.size() + " test"));
+ }
+
+ private static Path getJunitDependency() {
+ String junitPath =
+ Arrays.stream(System.getProperty("java.class.path").split(":"))
+ .filter(cp -> cp.endsWith(JUNIT_JAR))
+ .collect(Collectors.toSingle());
+ return Paths.get(junitPath);
+ }
+
+ private static Path getHamcrest() {
+ String junitPath =
+ Arrays.stream(System.getProperty("java.class.path").split(":"))
+ .filter(cp -> cp.endsWith(HAMCREST))
+ .collect(Collectors.toSingle());
+ return Paths.get(junitPath);
+ }
+
+ public static Path generateJarForRetraceBinaryTests(
+ TemporaryFolder temp, Collection<Class<? extends RetraceApiBinaryTest>> classes)
+ throws Exception {
+ Path jar = File.createTempFile("retrace_api_tests", ".jar", temp.getRoot()).toPath();
+ ZipBuilder zipBuilder = ZipBuilder.builder(jar);
+ for (Class<? extends RetraceApiBinaryTest> retraceApiTest : classes) {
+ zipBuilder.addFilesRelative(
+ ToolHelper.getClassPathForTests(),
+ ToolHelper.getClassFilesForInnerClasses(retraceApiTest));
+ zipBuilder.addBytes(
+ ZipUtils.zipEntryNameForClass(retraceApiTest),
+ ClassFileTransformer.create(retraceApiTest)
+ .removeInnerClasses(
+ InnerClassPredicate.onName(
+ DescriptorUtils.getBinaryNameFromJavaType(retraceApiTest.getTypeName())))
+ .transform());
+ }
+ zipBuilder.addFilesRelative(
+ ToolHelper.getClassPathForTests(),
+ ToolHelper.getClassFileForTestClass(RetraceApiBinaryTest.class));
+ return zipBuilder.build();
+ }
+
+ public static Collection<Class<? extends RetraceApiBinaryTest>> getBinaryCompatibilityTests() {
+ return CLASSES_FOR_BINARY_COMPATIBILITY;
+ }
+
+ private static boolean testIsSpecifiedAsBinaryOrPending(Class<?> clazz) {
+ return CLASSES_FOR_BINARY_COMPATIBILITY.contains(clazz)
+ || CLASSES_PENDING_BINARY_COMPATIBILITY.contains(clazz);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/NonVirtualOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/NonVirtualOverrideTest.java
index 4a8306a..801d678 100644
--- a/src/test/java/com/android/tools/r8/shaking/NonVirtualOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/NonVirtualOverrideTest.java
@@ -4,9 +4,9 @@
package com.android.tools.r8.shaking;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
-import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -105,9 +105,9 @@
"In C.m3()",
"In A.m4()",
"In A.m1()", // With Java: Caught IllegalAccessError when calling B.m1()
- "In A.m3()", // With Java: Caught IncompatibleClassChangeError when calling B.m3()
+ "Caught IncompatibleClassChangeError when calling B.m3()",
"In C.m1()", // With Java: Caught IllegalAccessError when calling B.m1()
- "In C.m3()", // With Java: Caught IncompatibleClassChangeError when calling B.m3()
+ "Caught IncompatibleClassChangeError when calling B.m3()",
"In C.m1()",
"In C.m3()",
"");
@@ -178,9 +178,11 @@
ClassSubject classSubject = inspector.clazz(B.class.getName());
assertThat(classSubject, isPresentAndRenamed());
assertThat(classSubject.method("void", "m1", ImmutableList.of()), isPresent());
- assertThat(classSubject.method("void", "m2", ImmutableList.of()), not(isPresent()));
- assertThat(classSubject.method("void", "m3", ImmutableList.of()), isPresent());
- assertThat(classSubject.method("void", "m4", ImmutableList.of()), not(isPresent()));
+ assertThat(classSubject.method("void", "m2", ImmutableList.of()), isAbsent());
+ assertThat(
+ classSubject.method("void", "m3", ImmutableList.of()),
+ parameters.isCfRuntime() ? isPresent() : isAbsent());
+ assertThat(classSubject.method("void", "m4", ImmutableList.of()), isAbsent());
}
}
@@ -263,7 +265,8 @@
System.out.println("In B.m2()");
}
- // Made static in the dump below. This method is targeted and can therefore not be removed.
+ // Made static in the dump below. Ends up dead as the targeting call is replaced by throw ICCE.
+ // Except in non-desugaring CF the method will remain instead of inserting a stub.
@Override
public void m3() {
System.out.println("In B.m3()");
diff --git a/src/test/java/com/android/tools/r8/shaking/ReturnTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ReturnTypeTest.java
index 98b7f80..82e9d69 100644
--- a/src/test/java/com/android/tools/r8/shaking/ReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ReturnTypeTest.java
@@ -85,7 +85,7 @@
// is
// always null, and replace the last call with null-throwing instruction.
// However, we want to test return type and parameter type are kept in this scenario.
- o.callSiteOptimizationOptions().disableTypePropagationForTesting();
+ o.callSiteOptimizationOptions().disableDynamicTypePropagationForTesting();
o.enableInlining = false;
})
.run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/shaking/clinit/ClassInitializationTriggersIndirectInterfaceInitializationTest.java b/src/test/java/com/android/tools/r8/shaking/clinit/ClassInitializationTriggersIndirectInterfaceInitializationTest.java
index b427736..29960f9 100644
--- a/src/test/java/com/android/tools/r8/shaking/clinit/ClassInitializationTriggersIndirectInterfaceInitializationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/clinit/ClassInitializationTriggersIndirectInterfaceInitializationTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.shaking.clinit;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.onlyIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@ -51,22 +51,27 @@
.compile()
.inspect(
inspector -> {
- // Verify that I's class initializer is still present.
ClassSubject iClassSubject = inspector.clazz(I.class);
- assertThat(iClassSubject, isPresent());
- assertThat(
- iClassSubject.clinit(),
- onlyIf(hasDefaultInterfaceMethodsSupport(parameters), isPresent()));
-
- // Verify that J is still there.
ClassSubject jClassSubject = inspector.clazz(J.class);
- assertThat(jClassSubject, isPresent());
-
- // Verify that A still implements J.
ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- assertEquals(1, aClassSubject.getDexProgramClass().getInterfaces().size());
- assertTrue(aClassSubject.isImplementing(jClassSubject));
+ if (hasDefaultInterfaceMethodsSupport(parameters)) {
+ // Verify that I's class initializer is still present.
+ assertThat(iClassSubject, isPresent());
+ assertThat(iClassSubject.clinit(), isPresent());
+
+ // Verify that J is still there.
+ assertThat(jClassSubject, isPresent());
+
+ // Verify that A still implements J.
+ assertThat(aClassSubject, isPresent());
+ assertEquals(1, aClassSubject.getDexProgramClass().getInterfaces().size());
+ assertTrue(aClassSubject.isImplementing(jClassSubject));
+ } else {
+ // All interfaces are gone and the default methods companion call is inlined.
+ assertThat(iClassSubject, isAbsent());
+ assertThat(jClassSubject, isAbsent());
+ assertThat(aClassSubject, isAbsent());
+ }
})
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLinesIf(
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 c2be7a8..02dfda4 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
@@ -3,8 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking.desugar;
-import static org.hamcrest.CoreMatchers.containsString;
-
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestDiagnosticMessages;
@@ -106,14 +104,8 @@
.enableNoVerticalClassMergingAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep interface **.I { static void foo(); }")
- .allowDiagnosticWarningMessages()
.compile()
- .inspectDiagnosticMessages(
- m ->
- m.assertWarningsCount(1)
- .assertWarningMessageThatMatches(containsString("static void foo()"))
- .assertWarningMessageThatMatches(containsString("is ignored"))
- .assertWarningMessageThatMatches(containsString("will be desugared")))
+ .inspectDiagnosticMessages(TestDiagnosticMessages::assertNoMessages)
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutput(EXPECTED_OUTPUT);
}
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 19b87e4..01d977a 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
@@ -4,7 +4,6 @@
package com.android.tools.r8.shaking.ifrule.interfacemethoddesugaring;
-import static com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringForTesting.getCompanionClassNameSuffix;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPublic;
import static com.android.tools.r8.utils.codeinspector.Matchers.isStatic;
@@ -12,6 +11,8 @@
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
@@ -34,9 +35,17 @@
private final TestParameters parameters;
+ private static final String STATIC_STR = "In Interface.staticMethod()";
+ private static final String VIRTUAL_STR = "In Interface.virtualMethod()";
+ private static final String EXPECTED_OUTPUT = StringUtils.lines(STATIC_STR, VIRTUAL_STR);
+
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withDexRuntimes().withApiLevel(AndroidApiLevel.M).build();
+ return getTestParameters()
+ .withCfRuntimes()
+ .withDexRuntimes()
+ .withApiLevel(AndroidApiLevel.M)
+ .build();
}
public IfRuleWithInterfaceMethodDesugaringTest(TestParameters parameters) {
@@ -44,50 +53,64 @@
}
@Test
+ public void testReference() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addTestClasspath()
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+
+ @Test
public void test() throws Exception {
- String expectedOutput =
- StringUtils.lines("In Interface.staticMethod()", "In Interface.virtualMethod()");
-
- testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expectedOutput);
-
CodeInspector inspector =
testForR8(parameters.getBackend())
.addInnerClasses(IfRuleWithInterfaceMethodDesugaringTest.class)
.addKeepMainRule(TestClass.class)
.addKeepRules(
"-if class " + Interface.class.getTypeName() + " {",
- " !public static void staticMethod();",
+ " static void staticMethod();",
"}",
"-keep class " + Unused1.class.getTypeName(),
"-if class " + Interface.class.getTypeName() + " {",
- " !public !static void virtualMethod();",
+ " !static void virtualMethod();",
"}",
"-keep class " + Unused2.class.getTypeName())
- .allowUnusedProguardConfigurationRules()
+ .allowUnusedProguardConfigurationRules(parameters.isDexRuntime())
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .compile()
.run(parameters.getRuntime(), TestClass.class)
- .assertSuccessWithOutput(expectedOutput)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT)
.inspector();
- ClassSubject classSubject =
- inspector.clazz(Interface.class.getTypeName() + getCompanionClassNameSuffix());
- assertThat(classSubject, isPresent());
- assertEquals(2, classSubject.allMethods().size());
+ if (parameters.isCfRuntime()) {
+ ClassSubject itfClass = inspector.clazz(Interface.class.getTypeName());
+ assertThat(itfClass, isPresent());
+ assertThat(itfClass.uniqueMethodWithName("staticMethod"), isPresent());
+ assertThat(itfClass.uniqueMethodWithName("virtualMethod"), isPresent());
+ assertThat(inspector.clazz(Unused1.class), isPresent());
+ assertThat(inspector.clazz(Unused2.class), isPresent());
+ return;
+ }
+ ClassSubject classSubject = inspector.clazz(Interface.class.getTypeName()).toCompanionClass();
+ assertThat(classSubject, isPresent());
+
+ // NeverInline is only applicable to the static method at this point (could change).
+ assertEquals(1, classSubject.allMethods().size());
MethodSubject staticMethodSubject = classSubject.uniqueMethodWithName("staticMethod");
assertThat(staticMethodSubject, allOf(isPresent(), isPublic(), isStatic()));
+ assertTrue(staticMethodSubject.streamInstructions().anyMatch(i -> i.isConstString(STATIC_STR)));
- // TODO(b/120764902): MethodSubject.getOriginalName() not working in presence of desugaring.
- MethodSubject virtualMethodSubject =
- classSubject.allMethods().stream()
- .filter(subject -> subject != staticMethodSubject)
- .findFirst()
- .get();
- assertThat(virtualMethodSubject, allOf(isPresent(), isPublic(), isStatic()));
+ // The virtual method is inlined as @NeverInline does not apply at this point (could change).
+ assertTrue(
+ inspector
+ .clazz(TestClass.class)
+ .mainMethod()
+ .streamInstructions()
+ .anyMatch(i -> i.isConstString(VIRTUAL_STR)));
// TODO(b/122875545): The Unused class should be present due to the -if rule.
assertThat(inspector.clazz(Unused1.class), not(isPresent()));
diff --git a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
index ca0aaa5..e9af866 100644
--- a/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/staticinterfacemethods/defaultmethods/StaticInterfaceMethodsTest.java
@@ -107,7 +107,7 @@
assertFalse(clazz.method("int", "method", ImmutableList.of()).isPresent());
}
- private void staticMethodKeptB159987443(CodeInspector inspector) {
+ private void staticMethodKept(CodeInspector inspector) {
ClassSubject clazz = inspector.clazz(InterfaceWithStaticMethods.class);
assertThat(clazz, isPresent());
MethodSubject method = clazz.method("int", "method", ImmutableList.of());
@@ -117,13 +117,12 @@
assertThat(companionClass, not(isPresent()));
} else {
assertThat(method, not(isPresent()));
- // TODO(159987443): The companion class should be present.
- assertThat(companionClass, not(isPresent()));
- // Also check that method exists on companion class.
+ assertThat(companionClass, isPresent());
+ assertThat(companionClass.uniqueMethodWithName("method"), isPresent());
}
}
- private void staticMethodKept(CodeInspector inspector) {
+ private void staticMethodKeptB160142903(CodeInspector inspector) {
ClassSubject clazz = inspector.clazz(InterfaceWithStaticMethods.class);
ClassSubject companionClass = clazz.toCompanionClass();
MethodSubject method = clazz.method("int", "method", ImmutableList.of());
@@ -136,7 +135,7 @@
// after desugaring, only the companion class is left.
assertThat(clazz, not(isPresent()));
assertThat(method, not(isPresent()));
- // TODO(159987443): The companion class should be present.
+ // TODO(160142903): The companion class should be present.
assertThat(companionClass, not(isPresent()));
// Also check that method exists on companion class.
}
@@ -168,7 +167,7 @@
"-keep interface " + InterfaceWithStaticMethods.class.getTypeName() + "{",
" <methods>;",
"}"),
- this::staticMethodKeptB159987443);
+ this::staticMethodKept);
}
@Test
@@ -196,7 +195,7 @@
"}");
}
}
- runTest(builder.build(), this::staticMethodKept);
+ runTest(builder.build(), this::staticMethodKeptB160142903);
}
public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
index 6ffbce9..92774e1 100644
--- a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
+++ b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
@@ -21,9 +21,12 @@
}
public static ClassReference syntheticCompanionClass(Class<?> clazz) {
+ return syntheticCompanionClass(Reference.classFromClass(clazz));
+ }
+
+ public static ClassReference syntheticCompanionClass(ClassReference clazz) {
return Reference.classFromDescriptor(
- InterfaceDesugaringForTesting.getCompanionClassDescriptor(
- Reference.classFromClass(clazz).getDescriptor()));
+ InterfaceDesugaringForTesting.getCompanionClassDescriptor(clazz.getDescriptor()));
}
private static ClassReference syntheticClass(Class<?> clazz, SyntheticKind kind, int id) {
@@ -72,7 +75,8 @@
public static boolean isExternalSynthetic(ClassReference reference) {
for (SyntheticKind kind : SyntheticKind.values()) {
- if (kind == SyntheticKind.RECORD_TAG) {
+ if (kind == SyntheticKind.RECORD_TAG
+ || kind == SyntheticKind.EMULATED_INTERFACE_MARKER_CLASS) {
continue;
}
if (kind.isFixedSuffixSynthetic) {
@@ -134,4 +138,9 @@
public static Matcher<String> containsExternalSyntheticReference() {
return containsString(SyntheticNaming.getPhaseSeparator(Phase.EXTERNAL));
}
+
+ public static boolean isInternalThrowNSME(MethodReference method) {
+ return SyntheticNaming.isSynthetic(
+ method.getHolderClass(), Phase.INTERNAL, SyntheticKind.THROW_NSME);
+ }
}
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
index 2bbcf4a..bc72103 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.transformers;
import static com.android.tools.r8.references.Reference.classFromTypeName;
+import static com.android.tools.r8.transformers.ClassFileTransformer.InnerClassPredicate.always;
import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromDescriptor;
import static com.android.tools.r8.utils.StringUtils.replaceAll;
import static org.objectweb.asm.Opcodes.ASM7;
@@ -31,6 +32,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
@@ -556,12 +558,31 @@
boolean test(String name, String typeDescriptor);
}
+ @FunctionalInterface
+ public interface InnerClassPredicate {
+ boolean test(String name, String outerName, String innerName, int access);
+
+ static InnerClassPredicate always() {
+ return (name, outerName, innerName, access) -> true;
+ }
+
+ static InnerClassPredicate onName(String name) {
+ return (otherName, outerName, innerName, access) -> Objects.equals(name, otherName);
+ }
+ }
+
public ClassFileTransformer removeInnerClasses() {
+ return removeInnerClasses(always());
+ }
+
+ public ClassFileTransformer removeInnerClasses(InnerClassPredicate predicate) {
return addClassTransformer(
new ClassTransformer() {
@Override
public void visitInnerClass(String name, String outerName, String innerName, int access) {
- // Intentionally empty.
+ if (!predicate.test(name, outerName, innerName, access)) {
+ super.visitInnerClass(name, outerName, innerName, access);
+ }
}
});
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassOrMemberSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassOrMemberSubject.java
index bca691f..2dc0774 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassOrMemberSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassOrMemberSubject.java
@@ -43,6 +43,7 @@
return getAccessFlags().isStatic();
}
+ @Override
public final boolean isSynthetic() {
return getAccessFlags().isSynthetic();
}
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 f552a25..b100332 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
@@ -4,8 +4,6 @@
package com.android.tools.r8.utils.codeinspector;
-import static com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringForTesting.getCompanionClassNameSuffix;
-
import com.android.tools.r8.graph.ClassAccessFlags;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
@@ -13,11 +11,11 @@
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
import com.android.tools.r8.references.TypeReference;
import com.android.tools.r8.retrace.RetraceClassElement;
import com.android.tools.r8.retrace.RetraceClassResult;
import com.android.tools.r8.smali.SmaliBuilder;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.ListUtils;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
@@ -231,12 +229,7 @@
public abstract KotlinClassMetadata getKotlinClassMetadata();
public ClassSubject toCompanionClass() {
- String descriptor = reference.getDescriptor();
- return codeInspector.clazz(
- Reference.classFromDescriptor(
- descriptor.substring(0, descriptor.length() - 1)
- + getCompanionClassNameSuffix()
- + ";"));
+ return codeInspector.clazz(SyntheticItemsTestUtils.syntheticCompanionClass(reference));
}
public abstract RetraceClassResult retrace();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 77c68b3..76d76e5 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -3,8 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.utils.codeinspector;
-import static com.android.tools.r8.ir.desugar.itf.InterfaceDesugaringForTesting.getCompanionClassNameSuffix;
-
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.StringResource;
import com.android.tools.r8.TestDiagnosticMessagesImpl;
@@ -40,6 +38,7 @@
import com.android.tools.r8.retrace.Retracer;
import com.android.tools.r8.retrace.internal.DirectClassNameMapperProguardMapProducer;
import com.android.tools.r8.retrace.internal.RetracerImpl;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.BiMapContainer;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -328,7 +327,7 @@
}
public ClassSubject companionClassFor(Class<?> clazz) {
- return clazz(Reference.classFromTypeName(clazz.getTypeName() + getCompanionClassNameSuffix()));
+ return clazz(SyntheticItemsTestUtils.syntheticCompanionClass(clazz));
}
public void forAllClasses(Consumer<FoundClassSubject> inspection) {
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 cbbbb14..edeed5a 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
@@ -25,6 +25,7 @@
import com.android.tools.r8.utils.Visibility;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import java.util.function.Predicate;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
@@ -84,15 +85,24 @@
}
public static Matcher<MethodSubject> isBridge() {
+ return isMethodSatisfying("bridge", FoundMethodSubject::isBridge);
+ }
+
+ public static Matcher<MethodSubject> isInstanceInitializer() {
+ return isMethodSatisfying("instance initializer", FoundMethodSubject::isInstanceInitializer);
+ }
+
+ private static Matcher<MethodSubject> isMethodSatisfying(
+ String helperText, Predicate<FoundMethodSubject> predicate) {
return new TypeSafeMatcher<MethodSubject>() {
@Override
protected boolean matchesSafely(MethodSubject subject) {
- return subject.isPresent() && subject.isBridge();
+ return subject.isPresent() && predicate.test(subject.asFoundMethodSubject());
}
@Override
public void describeTo(Description description) {
- description.appendText(" bridge");
+ description.appendText(" " + helperText);
}
@Override
diff --git a/third_party/retrace/binary_compatibility.tar.gz.sha1 b/third_party/retrace/binary_compatibility.tar.gz.sha1
new file mode 100644
index 0000000..3825d93
--- /dev/null
+++ b/third_party/retrace/binary_compatibility.tar.gz.sha1
@@ -0,0 +1 @@
+63dd09b086d0d134219a379720c6b68a94afdf48
\ No newline at end of file
