Reproduce b/120951621: stripped-out Kotlin @DebugMetadata and getters.
Test:
$ tools/test.py --dex_vm=all *ReflectiveAnnotationUse*
Bug: 120951621, 119471127
Change-Id: I7f2b8a0716614a4fa41024ea3eefa84c48fc74a9
diff --git a/src/test/java/com/android/tools/r8/KotlinTestBase.java b/src/test/java/com/android/tools/r8/KotlinTestBase.java
new file mode 100644
index 0000000..9139583
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/KotlinTestBase.java
@@ -0,0 +1,34 @@
+// Copyright (c) 2018, 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.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.FileUtils;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public abstract class KotlinTestBase extends TestBase {
+ private static final String RSRC = "kotlinR8TestResources";
+
+ protected final KotlinTargetVersion targetVersion;
+
+ protected KotlinTestBase(KotlinTargetVersion targetVersion) {
+ this.targetVersion = targetVersion;
+ }
+
+ protected Path getKotlinJarFile(String folder) {
+ return Paths.get(ToolHelper.TESTS_BUILD_DIR, RSRC,
+ targetVersion.getFolderName(), folder + FileUtils.JAR_EXTENSION);
+ }
+
+ protected Path getJavaJarFile(String folder) {
+ return Paths.get(ToolHelper.TESTS_BUILD_DIR, RSRC,
+ targetVersion.getFolderName(), folder + ".java" + FileUtils.JAR_EXTENSION);
+ }
+
+ protected Path getMappingfile(String folder, String mappingFileName) {
+ return Paths.get(ToolHelper.TESTS_DIR, RSRC, folder, mappingFileName);
+ }
+
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/MetadataStripTest.java
index dc2ba39..eca25fb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/MetadataStripTest.java
@@ -10,19 +10,15 @@
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
-import com.android.tools.r8.TestBase;
+import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.utils.FileUtils;
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.google.common.collect.ImmutableList;
-import java.nio.file.Path;
-import java.nio.file.Paths;
import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
@@ -30,12 +26,11 @@
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
-public class MetadataStripTest extends TestBase {
+public class MetadataStripTest extends KotlinTestBase {
private static final String METADATA_DESCRIPTOR = "Lkotlin/Metadata;";
private static final String KEEP_ANNOTATIONS = "-keepattributes *Annotation*";
private final Backend backend;
- private final KotlinTargetVersion targetVersion;
private Consumer<InternalOptions> optionsModifier =
o -> {
@@ -49,8 +44,8 @@
}
public MetadataStripTest(Backend backend, KotlinTargetVersion targetVersion) {
+ super(targetVersion);
this.backend = backend;
- this.targetVersion = targetVersion;
}
@Test
@@ -62,7 +57,6 @@
.addProgramFiles(getKotlinJarFile(folder))
.addProgramFiles(getJavaJarFile(folder))
.addProgramFiles(ToolHelper.getKotlinReflectJar())
- .enableProguardTestOptions()
.enableInliningAnnotations()
.addKeepMainRule(mainClassName)
.addKeepRules(KEEP_ANNOTATIONS)
@@ -91,13 +85,4 @@
return null;
}
- private Path getKotlinJarFile(String folder) {
- return Paths.get(ToolHelper.TESTS_BUILD_DIR, "kotlinR8TestResources",
- targetVersion.getFolderName(), folder + FileUtils.JAR_EXTENSION);
- }
-
- private Path getJavaJarFile(String folder) {
- return Paths.get(ToolHelper.TESTS_BUILD_DIR, "kotlinR8TestResources",
- targetVersion.getFolderName(), folder + ".java" + FileUtils.JAR_EXTENSION);
- }
}
diff --git a/src/test/java/com/android/tools/r8/shaking/EnclosingMethodTest.java b/src/test/java/com/android/tools/r8/shaking/EnclosingMethodTest.java
index a4806f0..72311a9 100644
--- a/src/test/java/com/android/tools/r8/shaking/EnclosingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EnclosingMethodTest.java
@@ -3,12 +3,14 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking;
+import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
@@ -72,12 +74,8 @@
@Test
public void testR8() throws Exception {
- DexVm vm = ToolHelper.getDexVm();
- assumeTrue("Known to be broken at 5.1.1 and 6.0.1 due to access to fragile EnclosingMethod.",
- vm.isOlderThanOrEqual(DexVm.ART_4_4_4_HOST) && vm.isNewerThan(DexVm.ART_6_0_1_HOST));
R8TestBuilder builder = testForR8(backend)
.addProgramFiles(classPaths)
- .enableProguardTestOptions()
.enableInliningAnnotations()
.addKeepMainRule(MAIN)
.addKeepRules("-keep class **.GetName*")
@@ -85,6 +83,16 @@
if (!enableMinification) {
builder.addKeepRules("-dontobfuscate");
}
- builder.run(MAIN).assertSuccessWithOutput(JAVA_OUTPUT);
+
+ TestRunResult result = builder.run(MAIN);
+ if (backend == Backend.DEX) {
+ if (ToolHelper.getDexVm().getVersion().isNewerThan(Version.V4_4_4)
+ && ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(Version.V6_0_1)) {
+ result.assertFailureWithErrorThatMatches(containsString("IncompatibleClassChangeError"));
+ return;
+ }
+ }
+
+ result.assertSuccessWithOutput(JAVA_OUTPUT);
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
new file mode 100644
index 0000000..43736bd
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -0,0 +1,228 @@
+// Copyright (c) 2018, 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.annotations;
+
+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.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.AndroidApp;
+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.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ReflectiveAnnotationUseTest extends KotlinTestBase {
+ private static final String FOLDER = "internal_annotation";
+ private static final String MAIN_CLASS_NAME = "internal_annotation.MainKt";
+ private static final String ANNOTATION_NAME = "internal_annotation.Annotation";
+ private static final String KEEP_ANNOTATIONS = "-keepattributes *Annotation*";
+
+ private static final String JAVA_OUTPUT = StringUtils.lines(
+ "Impl::toString",
+ "Impl::Annotation::field2.Impl::Annotation::field2(Impl::Annotation::field2:2)"
+ );
+
+ private static final String OUTPUT_WITHOUT_ANNOTATION = StringUtils.lines(
+ "Impl::toString",
+ "null"
+ );
+
+ private final Backend backend;
+ private final boolean minify;
+
+ @Parameterized.Parameters(name = "Backend: {0} target: {1} minify: {2}")
+ public static Collection<Object[]> data() {
+ return buildParameters(Backend.values(), KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
+ public ReflectiveAnnotationUseTest(
+ Backend backend, KotlinTargetVersion targetVersion, boolean minify) {
+ super(targetVersion);
+ this.backend = backend;
+ this.minify = minify;
+ }
+
+ @Test
+ public void b120951621_JVMoutput() throws Exception {
+ assumeTrue("Only run JVM reference once (for CF backend)", backend == Backend.CF);
+ AndroidApp app = AndroidApp.builder()
+ .addProgramFile(getKotlinJarFile(FOLDER))
+ .addProgramFile(getJavaJarFile(FOLDER))
+ .build();
+ String result = runOnJava(app, MAIN_CLASS_NAME);
+ assertEquals(JAVA_OUTPUT, result);
+ }
+
+ @Test
+ public void b120951621_keepAll() throws Exception {
+ R8TestBuilder builder = testForR8(backend)
+ .addProgramFiles(getKotlinJarFile(FOLDER))
+ .addProgramFiles(getJavaJarFile(FOLDER))
+ .addKeepMainRule(MAIN_CLASS_NAME)
+ .addKeepRules(KEEP_ANNOTATIONS)
+ .addKeepRules(
+ "-keep @interface " + ANNOTATION_NAME + " {",
+ " *;",
+ "}"
+ );
+ if (!minify) {
+ builder.noMinification();
+ }
+ TestRunResult result = builder.run(MAIN_CLASS_NAME);
+
+ result.assertSuccessWithOutput(JAVA_OUTPUT);
+
+ CodeInspector inspector = result.inspector();
+ ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
+ assertThat(clazz, isPresent());
+ assertThat(clazz, not(isRenamed()));
+ MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ assertThat(f1, isPresent());
+ assertThat(f1, not(isRenamed()));
+ MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ assertThat(f2, isPresent());
+ assertThat(f2, not(isRenamed()));
+ MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ assertThat(f3, isPresent());
+ assertThat(f3, not(isRenamed()));
+ MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ assertThat(f4, isPresent());
+ assertThat(f4, not(isRenamed()));
+ }
+
+ @Test
+ public void b120951621_partiallyKeep() throws Exception {
+ R8TestBuilder builder = testForR8(backend)
+ .addProgramFiles(getKotlinJarFile(FOLDER))
+ .addProgramFiles(getJavaJarFile(FOLDER))
+ .addKeepMainRule(MAIN_CLASS_NAME)
+ .addKeepRules(KEEP_ANNOTATIONS)
+ .addKeepRules(
+ "-keep,allowobfuscation @interface " + ANNOTATION_NAME + " {",
+ " java.lang.String *f2();",
+ "}"
+ );
+ if (!minify) {
+ builder.noMinification();
+ }
+ TestRunResult result = builder.run(MAIN_CLASS_NAME);
+
+ if (backend == Backend.DEX) {
+ if (ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(Version.V4_4_4)) {
+ result.assertFailureWithErrorThatMatches(
+ containsString("failure in processEncodedAnnotation"));
+ return;
+ }
+ if (ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(Version.V6_0_1)) {
+ result.assertFailureWithErrorThatMatches(containsString("IncompatibleClassChangeError"));
+ return;
+ }
+ result.assertSuccessWithOutput(OUTPUT_WITHOUT_ANNOTATION);
+ } else {
+ result.assertSuccessWithOutput(JAVA_OUTPUT);
+ }
+
+ CodeInspector inspector = result.inspector();
+ ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
+ assertThat(clazz, isPresent());
+ assertEquals(minify, clazz.isRenamed());
+ MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ assertThat(f1, isPresent());
+ assertThat(f1, not(isRenamed()));
+ MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ assertThat(f2, isPresent());
+ assertThat(f2, not(isRenamed()));
+ MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ assertThat(f3, not(isPresent()));
+ MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ assertThat(f4, not(isPresent()));
+ }
+
+ @Test
+ public void b120951621_keepAnnotation() throws Exception {
+ R8TestBuilder builder = testForR8(backend)
+ .addProgramFiles(getKotlinJarFile(FOLDER))
+ .addProgramFiles(getJavaJarFile(FOLDER))
+ .addKeepMainRule(MAIN_CLASS_NAME)
+ .addKeepRules(KEEP_ANNOTATIONS);
+ if (!minify) {
+ builder.noMinification();
+ }
+ TestRunResult result = builder.run(MAIN_CLASS_NAME);
+
+ if (backend == Backend.DEX) {
+ if (ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(Version.V4_4_4)) {
+ result.assertFailureWithErrorThatMatches(
+ containsString("failure in processEncodedAnnotation"));
+ return;
+ }
+ if (ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(Version.V6_0_1)) {
+ result.assertFailureWithErrorThatMatches(containsString("IncompatibleClassChangeError"));
+ return;
+ }
+ result.assertSuccessWithOutput(OUTPUT_WITHOUT_ANNOTATION);
+ } else {
+ result.assertSuccessWithOutput(JAVA_OUTPUT);
+ }
+
+ CodeInspector inspector = result.inspector();
+ ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
+ assertThat(clazz, isPresent());
+ assertEquals(minify, clazz.isRenamed());
+ MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ assertThat(f1, isPresent());
+ assertThat(f1, not(isRenamed()));
+ MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ assertThat(f2, isPresent());
+ assertThat(f2, not(isRenamed()));
+ MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ assertThat(f3, not(isPresent()));
+ MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ assertThat(f4, not(isPresent()));
+ }
+
+ @Test
+ public void b120951621_noKeep() throws Exception {
+ R8TestBuilder builder = testForR8(backend)
+ .addProgramFiles(getKotlinJarFile(FOLDER))
+ .addProgramFiles(getJavaJarFile(FOLDER))
+ .addKeepMainRule(MAIN_CLASS_NAME);
+ if (!minify) {
+ builder.noMinification();
+ }
+ TestRunResult result = builder.run(MAIN_CLASS_NAME);
+ result.assertSuccessWithOutput(OUTPUT_WITHOUT_ANNOTATION);
+
+ CodeInspector inspector = result.inspector();
+ ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
+ assertThat(clazz, isPresent());
+ assertEquals(minify, clazz.isRenamed());
+ MethodSubject f1 = clazz.uniqueMethodWithName("f1");
+ assertThat(f1, not(isPresent()));
+ MethodSubject f2 = clazz.uniqueMethodWithName("f2");
+ assertThat(f2, not(isPresent()));
+ MethodSubject f3 = clazz.uniqueMethodWithName("f3");
+ assertThat(f3, not(isPresent()));
+ MethodSubject f4 = clazz.uniqueMethodWithName("f4");
+ assertThat(f4, not(isPresent()));
+ }
+
+}
diff --git a/src/test/kotlinR8TestResources/internal_annotation/Annotation.kt b/src/test/kotlinR8TestResources/internal_annotation/Annotation.kt
new file mode 100644
index 0000000..40bc6b0
--- /dev/null
+++ b/src/test/kotlinR8TestResources/internal_annotation/Annotation.kt
@@ -0,0 +1,38 @@
+// Copyright (c) 2018, 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 internal_annotation
+
+@Target(AnnotationTarget.CLASS)
+internal annotation class Annotation(
+ @get:JvmName("f1")
+ val field1: Int = 0,
+ @get:JvmName("f2")
+ val field2: String = "",
+ @get:JvmName("f3")
+ val field3: IntArray = [],
+ @get:JvmName("f4")
+ val field4: Array<String> = []
+)
+
+@JvmName("foo")
+internal fun Base.foo(): StackTraceElement? {
+ val anno = getMyAnnotation() ?: return null
+ // Note that only Annotation.f(1|2) will be live.
+ return StackTraceElement(anno.field2, anno.field2, anno.field2, anno.field1)
+}
+
+// To prevent Annotation.f(3|4) from being stripped out by kotlinc
+internal fun Base.getUnusedFields(): Array<String>? {
+ val anno = getMyAnnotation() ?: return null
+ val res = arrayListOf<String>()
+ for ((i, idx) in anno.field3.withIndex()) {
+ if (idx == i % 8) {
+ res.add(anno.field4[i])
+ }
+ }
+ return res.toTypedArray()
+}
+
+private fun Base.getMyAnnotation(): Annotation? =
+ javaClass.getAnnotation(Annotation::class.java)
diff --git a/src/test/kotlinR8TestResources/internal_annotation/Base.kt b/src/test/kotlinR8TestResources/internal_annotation/Base.kt
new file mode 100644
index 0000000..cedf902
--- /dev/null
+++ b/src/test/kotlinR8TestResources/internal_annotation/Base.kt
@@ -0,0 +1,29 @@
+// Copyright (c) 2018, 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 internal_annotation
+
+@Annotation(8, "Base::Annotation::field2", [], [])
+internal abstract class Base {
+ protected abstract fun foo(): Any?
+
+ public override fun toString(): String =
+ "${foo() ?: this::class.java.name}"
+}
+
+// If we don't adjust annotation values, lack of f(3|4) will trigger errors on legacy VMs.
+@Annotation(2, "Impl::Annotation::field2", [3], ["field4"])
+internal class Impl(val flag: Boolean) : Base() {
+ override fun foo(): Any? {
+ return when (flag) {
+ true -> null
+ false -> this
+ }
+ }
+
+ public override fun toString(): String =
+ if (flag)
+ super.toString()
+ else
+ "Impl::toString"
+}
\ No newline at end of file
diff --git a/src/test/kotlinR8TestResources/internal_annotation/main.kt b/src/test/kotlinR8TestResources/internal_annotation/main.kt
new file mode 100644
index 0000000..ce5c85d
--- /dev/null
+++ b/src/test/kotlinR8TestResources/internal_annotation/main.kt
@@ -0,0 +1,10 @@
+// Copyright (c) 2018, 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 internal_annotation
+
+fun main(args: Array<String>) {
+ val i = Impl(false)
+ println("$i")
+ println("${i.foo()}")
+}
