Remove redundant implements clauses during tree pruning
Change-Id: I937c9cf49fb8e96295d02cbaaa47833957dfb7a7
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 09d06a5..e827a25 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -123,6 +123,10 @@
return accessFlags;
}
+ public DexTypeList getInterfaces() {
+ return interfaces;
+ }
+
public DexString getSourceFile() {
return sourceFile;
}
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 ffc2da4..caade38 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -73,8 +73,9 @@
}
private DirectMappedDexApplication.Builder removeUnused(DirectMappedDexApplication application) {
- return application.builder()
- .replaceProgramClasses(getNewProgramClasses(application.classes()));
+ return application
+ .builder()
+ .replaceProgramClasses(getNewProgramClasses(application.classesWithDeterministicOrder()));
}
private List<DexProgramClass> getNewProgramClasses(List<DexProgramClass> classes) {
@@ -120,23 +121,14 @@
}
private void pruneUnusedInterfaces(DexProgramClass clazz) {
- boolean implementsUnusedInterfaces = false;
- for (DexType type : clazz.interfaces.values) {
- // TODO(christofferqa): Extend unused interface removal to library classes.
- if (!isTypeLive(type)) {
- implementsUnusedInterfaces = true;
- break;
- }
- }
-
- if (!implementsUnusedInterfaces) {
- return;
- }
-
Set<DexType> reachableInterfaces = new LinkedHashSet<>();
for (DexType type : clazz.interfaces.values) {
retainReachableInterfacesFrom(type, reachableInterfaces);
}
+ if (!reachableInterfaces.isEmpty()) {
+ removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(
+ clazz.superType, reachableInterfaces);
+ }
if (reachableInterfaces.isEmpty()) {
clazz.interfaces = DexTypeList.empty();
} else {
@@ -144,6 +136,23 @@
}
}
+ private void removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(
+ DexType type, Set<DexType> interfaces) {
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz == null) {
+ return;
+ }
+ for (DexType itf : clazz.interfaces) {
+ if (interfaces.remove(itf) && interfaces.isEmpty()) {
+ return;
+ }
+ }
+ if (clazz.superType != null) {
+ assert !interfaces.isEmpty();
+ removeInterfacesImplementedDirectlyAndIndirectlyByClassFromSet(clazz.superType, interfaces);
+ }
+ }
+
private void retainReachableInterfacesFrom(DexType type, Set<DexType> reachableInterfaces) {
if (isTypeLive(type)) {
reachableInterfaces.add(type);
diff --git a/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java b/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java
new file mode 100644
index 0000000..1d559b7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/interfaces/RedundantImplementsClauseTest.java
@@ -0,0 +1,120 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.interfaces;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.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.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+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 RedundantImplementsClauseTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return TestBase.getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public RedundantImplementsClauseTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("A", "B", "C");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject iClassSubject = inspector.clazz(I.class);
+ assertThat(iClassSubject, isPresent());
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ assertTrue(
+ aClassSubject
+ .getDexProgramClass()
+ .getInterfaces()
+ .contains(iClassSubject.getDexProgramClass().getType()));
+
+ ClassSubject bClassSubject = inspector.clazz(B.class);
+ assertThat(bClassSubject, isPresent());
+ assertFalse(
+ bClassSubject
+ .getDexProgramClass()
+ .getInterfaces()
+ .contains(iClassSubject.getDexProgramClass().getType()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ test(new A());
+ test(new B());
+ test(new C());
+ }
+
+ @NeverInline
+ static void test(I instance) {
+ instance.m();
+ }
+ }
+
+ interface I {
+
+ void m();
+ }
+
+ @NeverClassInline
+ @NoVerticalClassMerging
+ static class A implements I {
+
+ @Override
+ public void m() {
+ System.out.println("A");
+ }
+ }
+
+ @NeverClassInline
+ static class B extends A implements I {
+
+ @Override
+ public void m() {
+ System.out.println("B");
+ }
+ }
+
+ @NeverClassInline
+ static class C implements I {
+
+ @Override
+ public void m() {
+ System.out.println("C");
+ }
+ }
+}
