Keep dependent items for indirectly instantiated types
Change-Id: Id4980592c676375fc59565f28946d226e8fa7451
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 3560e2f..378cca0 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -1122,7 +1122,7 @@
// For all instance fields visible from the class, mark them live if we have seen a read.
transitionFieldsForInstantiatedClass(clazz.type);
// Add all dependent instance members to the workqueue.
- rootSet.forEachDependentNonStaticMember(clazz, appView, this::enqueueDependentItem);
+ transitionDependentItemsForInstantiatedClass(clazz);
}
/**
@@ -1236,6 +1236,19 @@
} while (type != null && !instantiatedTypes.contains(type));
}
+ private void transitionDependentItemsForInstantiatedClass(DexClass clazz) {
+ DexClass current = clazz;
+ do {
+ // Handle keep rules that are dependent on the class being instantiated.
+ rootSet.forEachDependentNonStaticMember(clazz, appView, this::enqueueDependentItem);
+
+ // Visit the super type.
+ current = current.superType != null ? appView.definitionFor(current.superType) : null;
+ } while (current != null
+ && current.isProgramClass()
+ && !instantiatedTypes.contains(current.type));
+ }
+
private void markStaticFieldAsLive(DexField field, KeepReason reason) {
markStaticFieldAsLive(field, reason, appInfo.resolveField(field));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
new file mode 100644
index 0000000..327f61d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.keepclassmembers;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+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 com.android.tools.r8.utils.codeinspector.FieldSubject;
+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 KeepClassMembersRuleOnIndirectlyInstantiatedClassTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().build();
+ }
+
+ public KeepClassMembersRuleOnIndirectlyInstantiatedClassTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(KeepClassMembersRuleOnIndirectlyInstantiatedClassTest.class)
+ .addKeepMainRule(TestClass.class)
+ .addKeepRules(
+ "-keepclassmembers class " + A.class.getTypeName() + " {",
+ " java.lang.String greeting;",
+ "}")
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getRuntime())
+ .compile()
+ .inspect(this::verifyFieldIsPresent)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void verifyFieldIsPresent(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(A.class);
+ assertThat(classSubject, isPresent());
+
+ FieldSubject fieldSubject = classSubject.uniqueFieldWithName("greeting");
+ assertThat(fieldSubject, isPresent());
+ assertThat(fieldSubject, not(isRenamed()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) throws Exception {
+ B b = new B();
+ reflectivelyWriteFieldWithName(b, "greeting", "Hello world!");
+ System.out.println(reflectivelyReadFieldWithName(b, "greeting"));
+ }
+
+ @NeverInline
+ private static void reflectivelyWriteFieldWithName(Object o, String fieldName, String value)
+ throws Exception {
+ o.getClass().getField(fieldName).set(o, value);
+ }
+
+ @NeverInline
+ private static String reflectivelyReadFieldWithName(Object o, String fieldName)
+ throws Exception {
+ return (String) o.getClass().getField(fieldName).get(o);
+ }
+ }
+
+ @NeverMerge
+ static class A {
+
+ public String greeting;
+ }
+
+ static class B extends A {}
+}
