Version 2.1.33
Cherry pick: Disallow abstract methods on non-abstract classes
CL: https://r8-review.googlesource.com/c/r8/+/51861
Cherry pick: Remove abstract method to empty throwing method transformation in dex parser
CL: https://r8-review.googlesource.com/c/r8/+/51880
Cherry pick: Reproduce abstract method on non-abstract class warnings
CL: https://r8-review.googlesource.com/c/r8/+/51858
Bug: 158018192, 158069726
Change-Id: I2105e0fe4adaa07050d98f27ca79341432547008
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 0c85791..ea79264 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
// This field is accessed from release scripts using simple pattern matching.
// Therefore, changing this field could break our release scripts.
- public static final String LABEL = "2.1.32";
+ public static final String LABEL = "2.1.33";
private Version() {
}
diff --git a/src/main/java/com/android/tools/r8/dex/DexParser.java b/src/main/java/com/android/tools/r8/dex/DexParser.java
index 26dca03..a416e51 100644
--- a/src/main/java/com/android/tools/r8/dex/DexParser.java
+++ b/src/main/java/com/android/tools/r8/dex/DexParser.java
@@ -642,8 +642,7 @@
int size,
DexMethodAnnotation[] annotations,
DexParameterAnnotation[] parameters,
- boolean skipCodes,
- boolean ensureNonAbstract) {
+ boolean skipCodes) {
DexEncodedMethod[] methods = new DexEncodedMethod[size];
int methodIndex = 0;
MemberAnnotationIterator<DexMethod, DexAnnotationSet> annotationIterator =
@@ -661,19 +660,13 @@
code = codes.get(codeOff);
}
DexMethod method = indexedItems.getMethod(methodIndex);
- DexEncodedMethod encodedMethod =
+ methods[i] =
new DexEncodedMethod(
method,
accessFlags,
annotationIterator.getNextFor(method),
parameterAnnotationsIterator.getNextFor(method),
code);
- if (accessFlags.isAbstract() && ensureNonAbstract) {
- accessFlags.unsetAbstract();
- assert !options.isGeneratingClassFiles();
- encodedMethod = encodedMethod.toEmptyThrowingMethodDex(false);
- }
- methods[i] = encodedMethod;
}
return methods;
}
@@ -754,17 +747,13 @@
directMethodsSize,
annotationsDirectory.methods,
annotationsDirectory.parameters,
- classKind != ClassKind.PROGRAM,
- options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
- && !flags.isAbstract());
+ classKind != ClassKind.PROGRAM);
virtualMethods =
readMethods(
virtualMethodsSize,
annotationsDirectory.methods,
annotationsDirectory.parameters,
- classKind != ClassKind.PROGRAM,
- options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
- && !flags.isAbstract());
+ classKind != ClassKind.PROGRAM);
}
AttributesAndAnnotations attrs =
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index c2cdc32..be8c6f1 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -176,12 +176,10 @@
private boolean verifyNoAbstractMethodsOnNonAbstractClasses(
Iterable<DexEncodedMethod> methods, InternalOptions options) {
- if (options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()) {
- if (!isAbstract()) {
- for (DexEncodedMethod method : methods) {
- assert !method.isAbstract()
- : "Non-abstract method on abstract class: `" + method.method.toSourceString() + "`";
- }
+ if (options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug() && !isAbstract()) {
+ for (DexEncodedMethod method : methods) {
+ assert !method.isAbstract()
+ : "Non-abstract method on abstract class: `" + method.method.toSourceString() + "`";
}
}
return true;
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 7071fda..cf25051 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -767,11 +767,6 @@
null);
}
- public DexCode buildEmptyThrowingDexCode() {
- Instruction insn[] = {new Const(0, 0), new Throw(0)};
- return generateCodeFromTemplate(1, 0, insn);
- }
-
public DexEncodedMethod toEmptyThrowingMethod(InternalOptions options) {
// Note that we are not marking this instance obsolete, since this util is only used by
// TreePruner while keeping non-live yet targeted, empty method. Such method can be retrieved
@@ -794,17 +789,6 @@
return builder.build();
}
- public CfCode buildEmptyThrowingCfCode() {
- CfInstruction insn[] = {new CfConstNull(), new CfThrow()};
- return new CfCode(
- method.holder,
- 1,
- method.proto.parameters.size() + 1,
- Arrays.asList(insn),
- Collections.emptyList(),
- Collections.emptyList());
- }
-
private DexEncodedMethod toEmptyThrowingMethodCf() {
checkIfObsolete();
assert !shouldNotHaveCode();
@@ -818,6 +802,28 @@
return builder.build();
}
+ public Code buildEmptyThrowingCode(InternalOptions options) {
+ return options.isGeneratingClassFiles()
+ ? buildEmptyThrowingCfCode()
+ : buildEmptyThrowingDexCode();
+ }
+
+ public CfCode buildEmptyThrowingCfCode() {
+ CfInstruction insn[] = {new CfConstNull(), new CfThrow()};
+ return new CfCode(
+ method.holder,
+ 1,
+ method.proto.parameters.size() + 1,
+ Arrays.asList(insn),
+ Collections.emptyList(),
+ Collections.emptyList());
+ }
+
+ public DexCode buildEmptyThrowingDexCode() {
+ Instruction insn[] = {new Const(0, 0), new Throw(0)};
+ return generateCodeFromTemplate(1, 0, insn);
+ }
+
public DexEncodedMethod toMethodThatLogsError(AppView<?> appView) {
if (appView.options().isGeneratingDex()) {
return toMethodThatLogsErrorDexCode(appView.dexItemFactory());
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 75627a0..3a6d92b 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
@@ -489,6 +489,8 @@
public DexApplication convert(DexApplication application, ExecutorService executor)
throws ExecutionException {
removeLambdaDeserializationMethods();
+ workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+ executor, OptimizationFeedbackIgnore.getInstance());
timing.begin("IR conversion");
ThreadUtils.processItems(application.classes(), this::convertMethods, executor);
@@ -652,6 +654,28 @@
}
}
+ private void workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+ ExecutorService executorService, OptimizationFeedback feedback) throws ExecutionException {
+ if (!options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()) {
+ return;
+ }
+ assert delayedOptimizationFeedback.noUpdatesLeft();
+ ThreadUtils.processItems(
+ appView.appInfo().classes(),
+ clazz -> {
+ if (!clazz.isAbstract()) {
+ clazz.forEachMethod(
+ method -> {
+ if (method.isAbstract()) {
+ method.accessFlags.unsetAbstract();
+ finalizeEmptyThrowingCode(method, feedback);
+ }
+ });
+ }
+ },
+ executorService);
+ }
+
public DexApplication optimize() throws ExecutionException {
ExecutorService executor = Executors.newSingleThreadExecutor();
try {
@@ -667,6 +691,8 @@
computeReachabilitySensitivity(application);
collectLambdaMergingCandidates(application);
collectStaticizerCandidates(application);
+ workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+ executorService, simpleOptimizationFeedback);
// The process is in two phases in general.
// 1) Subject all DexEncodedMethods to optimization, except some optimizations that require
@@ -1705,10 +1731,7 @@
private void finalizeEmptyThrowingCode(DexEncodedMethod method, OptimizationFeedback feedback) {
assert options.isGeneratingClassFiles() || options.isGeneratingDex();
- Code emptyThrowingCode =
- options.isGeneratingClassFiles()
- ? method.buildEmptyThrowingCfCode()
- : method.buildEmptyThrowingDexCode();
+ Code emptyThrowingCode = method.buildEmptyThrowingCode(options);
method.setCode(emptyThrowingCode, appView);
feedback.markProcessed(method, ConstraintWithTarget.ALWAYS);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index 379fc28..5dc7874 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -726,11 +726,7 @@
// enumUnboxerRewriter will generate invalid code.
// To work around this problem we clear such methods, i.e., we replace the code object by
// an empty throwing code object, so reprocessing won't take time and will be valid.
- enumMethod.setCode(
- appView.options().isGeneratingClassFiles()
- ? enumMethod.buildEmptyThrowingCfCode()
- : enumMethod.buildEmptyThrowingDexCode(),
- appView);
+ enumMethod.setCode(enumMethod.buildEmptyThrowingCode(appView.options()), appView);
}
private DexEncodedMethod fixupEncodedMethodToUtility(
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 9696162..3de881b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -140,8 +140,7 @@
@Override
public void markProcessed(DexEncodedMethod method, ConstraintWithTarget state) {
- // Just as processed, don't provide any inlining constraints.
- method.markProcessed(ConstraintWithTarget.NEVER);
+ method.markProcessed(state);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 346caa4..fdaae48 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -300,8 +300,7 @@
// Final classes cannot be abstract, so we have to keep the method in that case.
// Also some other kinds of methods cannot be abstract, so keep them around.
boolean allowAbstract =
- (!options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
- || clazz.isAbstract())
+ (options.canUseAbstractMethodOnNonAbstractClass() || clazz.isAbstract())
&& !method.isFinal()
&& !method.accessFlags.isNative()
&& !method.accessFlags.isStrict()
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 8c92acf..71539ef 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1250,6 +1250,22 @@
return minApiLevel >= level.getLevel();
}
+ /**
+ * Dex2Oat issues a warning for abstract methods on non-abstract classes, so we never allow this.
+ *
+ * <p>Note that having an invoke instruction that targets an abstract method on a non-abstract
+ * class will fail with a verification error on Dalvik. Therefore, this must not be more
+ * permissive than {@code return minApiLevel >= AndroidApiLevel.L.getLevel()}.
+ *
+ * <p>See b/132953944.
+ */
+ @SuppressWarnings("ConstantConditions")
+ public boolean canUseAbstractMethodOnNonAbstractClass() {
+ boolean result = false;
+ assert !(result && canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug());
+ return result;
+ }
+
public boolean canUseConstClassInstructions(int cfVersion) {
assert isGeneratingClassFiles();
return cfVersion >= requiredCfVersionForConstClassInstructions();
@@ -1673,7 +1689,7 @@
//
// See b/132953944.
public boolean canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug() {
- return minApiLevel < AndroidApiLevel.L.getLevel();
+ return isGeneratingDex() && minApiLevel < AndroidApiLevel.L.getLevel();
}
// On dalvik we see issues when using an int value in places where a boolean, byte, char, or short
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index a109e20..61db3e3 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -135,7 +135,8 @@
box.proguardConfiguration,
box.syntheticProguardRules,
proguardMapBuilder.toString(),
- graphConsumer);
+ graphConsumer,
+ builder.getMinApiLevel());
switch (allowedDiagnosticMessages) {
case ALL:
compileResult.assertDiagnosticThatMatches(new IsAnything<>());
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 3a16807..5dac954 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -14,7 +14,6 @@
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
-import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
public class R8TestCompileResult extends TestCompileResult<R8TestCompileResult, R8TestRunResult> {
@@ -23,6 +22,7 @@
private final List<ProguardConfigurationRule> syntheticProguardRules;
private final String proguardMap;
private final CollectingGraphConsumer graphConsumer;
+ private final int minApiLevel;
R8TestCompileResult(
TestState state,
@@ -31,12 +31,14 @@
ProguardConfiguration proguardConfiguration,
List<ProguardConfigurationRule> syntheticProguardRules,
String proguardMap,
- CollectingGraphConsumer graphConsumer) {
+ CollectingGraphConsumer graphConsumer,
+ int minApiLevel) {
super(state, app, outputMode);
this.proguardConfiguration = proguardConfiguration;
this.syntheticProguardRules = syntheticProguardRules;
this.proguardMap = proguardMap;
this.graphConsumer = graphConsumer;
+ this.minApiLevel = minApiLevel;
}
@Override
@@ -65,11 +67,11 @@
}
@Override
- public CodeInspector inspector() throws IOException, ExecutionException {
+ public CodeInspector inspector() throws IOException {
return new CodeInspector(app, proguardMap);
}
- public GraphInspector graphInspector() throws IOException, ExecutionException {
+ public GraphInspector graphInspector() throws IOException {
assert graphConsumer != null;
return new GraphInspector(graphConsumer, inspector());
}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
index cacf66b..26186aa 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
@@ -635,9 +635,10 @@
.forEach(
p -> {
try {
- CodeInspector i = new CodeInspector(AndroidApp.builder().addProgramFiles(p).build());
+ CodeInspector i =
+ new CodeInspector(AndroidApp.builder().addProgramFiles(p).build());
assertFalse("Found " + clazz + " in file " + p, i.clazz(clazz).isPresent());
- } catch (IOException | ExecutionException e) {
+ } catch (IOException e) {
e.printStackTrace();
}
});
diff --git a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
new file mode 100644
index 0000000..2f95543
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
@@ -0,0 +1,131 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class AbstractMethodOnNonAbstractClassTest extends TestBase {
+
+ private static final String DEX2OAT_WARNING =
+ "is abstract, but the declaring class is neither abstract nor an interface";
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public AbstractMethodOnNonAbstractClassTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testCompat() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8Compat(parameters.getBackend())
+ .addInnerClasses(AbstractMethodOnNonAbstractClassTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ // A is not made abstract in compat mode.
+ ClassSubject classSubject = compileResult.inspector().clazz(A.class);
+ assertThat(classSubject, isPresent());
+ assertFalse(classSubject.isAbstract());
+
+ // A.m() is also not made abstract in compat mode.
+ MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+ assertThat(methodSubject, isPresent());
+ assertFalse(methodSubject.isAbstract());
+
+ if (parameters.isDexRuntime()) {
+ compileResult
+ .runDex2Oat(parameters.getRuntime())
+ .assertStderrMatches(not(containsString(DEX2OAT_WARNING)));
+ }
+
+ compileResult
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ @Test
+ public void testFull() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(AbstractMethodOnNonAbstractClassTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ // A is made abstract in full mode.
+ ClassSubject classSubject = compileResult.inspector().clazz(A.class);
+ assertThat(classSubject, isPresent());
+ assertTrue(classSubject.isAbstract());
+
+ // A.m() is also made abstract in full mode.
+ MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+ assertThat(methodSubject, isPresent());
+ assertTrue(methodSubject.isAbstract());
+
+ if (parameters.isDexRuntime()) {
+ // There is no warning due to both A and A.m() being abstract.
+ compileResult
+ .runDex2Oat(parameters.getRuntime())
+ .assertStderrMatches(not(containsString(DEX2OAT_WARNING)));
+ }
+
+ compileResult
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ A b = System.currentTimeMillis() > 0 ? new B() : new C();
+ b.m();
+ }
+ }
+
+ static class A {
+
+ // Never called directly on A, thus can be made abstract.
+ void m() {}
+ }
+
+ static class B extends A {
+
+ @Override
+ void m() {
+ System.out.println("Hello world!");
+ }
+ }
+
+ static class C extends A {
+
+ @Override
+ void m() {
+ throw new RuntimeException();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java b/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
index 912915b..ac43338 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
public class SmaliBuildTest extends SmaliTestBase {
@@ -23,7 +22,7 @@
CodeInspector inspector = new CodeInspector(application);
ClassSubject clazz = inspector.clazz("java.lang.String");
assertEquals(present, clazz.isPresent());
- } catch (IOException | ExecutionException e) {
+ } catch (IOException e) {
throw new RuntimeException(e);
}
}
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
index efcc42f..10962c8 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
@@ -126,7 +126,7 @@
ClassSubject clazz = inspector.clazz(className);
assertTrue(clazz.isPresent());
return clazz.getDexProgramClass();
- } catch (IOException | ExecutionException e) {
+ } catch (IOException e) {
throw new RuntimeException(e);
}
}
@@ -135,7 +135,7 @@
try {
CodeInspector inspector = new CodeInspector(appPath);
return getMethodSubject(inspector, signature);
- } catch (IOException | ExecutionException e) {
+ } catch (IOException e) {
throw new RuntimeException(e);
}
}
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 3f1ad69..1f1d744 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -337,6 +337,10 @@
});
}
+ public ClassFileTransformer unsetAbstract() {
+ return setAccessFlags(ClassAccessFlags::unsetAbstract);
+ }
+
public ClassFileTransformer setAnnotation() {
return setAccessFlags(
accessFlags -> {
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 39f7c44..b2edae2 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
@@ -55,7 +55,6 @@
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.ExecutionException;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
@@ -72,25 +71,25 @@
public static MethodSignature MAIN =
new MethodSignature("main", "void", new String[] {"java.lang.String[]"});
- public CodeInspector(String path) throws IOException, ExecutionException {
+ public CodeInspector(String path) throws IOException {
this(Paths.get(path));
}
- public CodeInspector(Path file, String mappingFile) throws IOException, ExecutionException {
+ public CodeInspector(Path file, String mappingFile) throws IOException {
this(Collections.singletonList(file), mappingFile, null);
}
- public CodeInspector(Path file) throws IOException, ExecutionException {
+ public CodeInspector(Path file) throws IOException {
this(Collections.singletonList(file), null, null);
}
- public CodeInspector(List<Path> files) throws IOException, ExecutionException {
+ public CodeInspector(List<Path> files) throws IOException {
this(files, null, null);
}
public CodeInspector(
List<Path> files, String mappingFile, Consumer<InternalOptions> optionsConsumer)
- throws IOException, ExecutionException {
+ throws IOException {
Path mappingPath = mappingFile != null ? Paths.get(mappingFile) : null;
if (mappingPath != null && Files.exists(mappingPath)) {
mapping = ClassNameMapper.mapperFromFile(mappingPath);
@@ -109,14 +108,14 @@
application = new ApplicationReader(input, options, timing).read();
}
- public CodeInspector(AndroidApp app) throws IOException, ExecutionException {
+ public CodeInspector(AndroidApp app) throws IOException {
this(
new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
.read(app.getProguardMapOutputData()));
}
public CodeInspector(AndroidApp app, Consumer<InternalOptions> optionsConsumer)
- throws IOException, ExecutionException {
+ throws IOException {
this(
new ApplicationReader(app, runOptionsConsumer(optionsConsumer), Timing.empty())
.read(app.getProguardMapOutputData()));
@@ -130,15 +129,13 @@
return internalOptions;
}
- public CodeInspector(AndroidApp app, Path proguardMapFile)
- throws IOException, ExecutionException {
+ public CodeInspector(AndroidApp app, Path proguardMapFile) throws IOException {
this(
new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
.read(StringResource.fromFile(proguardMapFile)));
}
- public CodeInspector(AndroidApp app, String proguardMapContent)
- throws IOException, ExecutionException {
+ public CodeInspector(AndroidApp app, String proguardMapContent) throws IOException {
this(
new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
.read(StringResource.fromString(proguardMapContent, Origin.unknown())));
diff --git a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
new file mode 100644
index 0000000..aca08d4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
@@ -0,0 +1,99 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.workaround;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbstract;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class InputWithAbstractMethodOnNonAbstractClassTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public InputWithAbstractMethodOnNonAbstractClassTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testD8() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+ testForD8()
+ .addProgramClasses(TestClass.class)
+ .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(TestClass.class)
+ .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(Greeter.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ @Test
+ public void testJVM() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClasses(TestClass.class)
+ .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ MethodSubject methodOfInterest = inspector.clazz(Greeter.class).uniqueMethodWithName("dead");
+ assertThat(methodOfInterest, isPresent());
+ if (parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.L)) {
+ assertThat(methodOfInterest, not(isAbstract()));
+ } else {
+ assertThat(methodOfInterest, isAbstract());
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ Greeter.greet();
+ }
+ }
+
+ /*not-*/ abstract static class Greeter {
+
+ static void greet() {
+ System.out.println("Hello world!");
+ }
+
+ abstract void dead();
+ }
+}
