Fix field mapping in tree fixer
Bug: 163311975
Change-Id: If0d794f459420552b0ea05ba96f713bbd5f191b5
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
index a10b066..5f5a62b 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
@@ -113,6 +113,11 @@
methodMap = methodMap.remap(remapMethods, Function.identity(), Function.identity());
}
+ public Builder mapField(DexField from, DexField to) {
+ fieldMap.put(from, to);
+ return this;
+ }
+
/** Unidirectional mapping from one method to another. */
public Builder recordExtraOriginalSignature(DexMethod from, DexMethod to) {
methodMap.setRepresentative(from, to);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
index b57adbf..e33137c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
@@ -389,8 +389,7 @@
DexField field = encodedField.field;
DexField newField = fixupFieldReference(field);
if (newField != encodedField.field) {
- // TODO(b/165498187): track mapped fields
- /* lensBuilder.map(field, newField); */
+ lensBuilder.mapField(field, newField);
setter.setField(i, encodedField.toTypeSubstitutedField(newField));
}
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
new file mode 100644
index 0000000..5ad8bf6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
@@ -0,0 +1,117 @@
+// 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isFieldOfArrayType;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isFieldOfType;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.A;
+import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.B;
+import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.Main;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import org.junit.Test;
+
+public class FieldTypeMergedTest extends HorizontalClassMergingTestBase {
+ public FieldTypeMergedTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+ super(parameters, enableHorizontalClassMerging);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+ .enableInliningAnnotations()
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("a", "b", "bar", "bar", "bar")
+ .inspect(
+ codeInspector -> {
+ ClassSubject aClassSubject = codeInspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ assertThat(
+ codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+
+ ClassSubject cClassSubject = codeInspector.clazz(C.class);
+ assertThat(codeInspector.clazz(C.class), isPresent());
+
+ // TODO(b/169318508): use cClassSubject.uniqueFieldWithName("fieldB")
+ FieldSubject fieldSubject = cClassSubject.allFields().get(0);
+ assertThat(fieldSubject, isPresent());
+ if (enableHorizontalClassMerging) {
+ assertThat(
+ fieldSubject, isFieldOfType(aClassSubject.getDexProgramClass().getType()));
+ }
+
+ // TODO(b/169318508): use cClassSubject.uniqueFieldWithName("fieldArrayB")
+ fieldSubject = cClassSubject.allFields().get(1);
+ assertThat(fieldSubject, isPresent());
+ assertTrue(fieldSubject.getFieldReference().type.isArrayType());
+ if (enableHorizontalClassMerging) {
+ assertThat(
+ fieldSubject,
+ isFieldOfArrayType(
+ codeInspector, aClassSubject.getDexProgramClass().getType()));
+ }
+ });
+ }
+
+ @NeverClassInline
+ public static class A {
+ public A() {
+ System.out.println("a");
+ }
+ }
+
+ @NeverClassInline
+ public static class B {
+ public B() {
+ System.out.println("b");
+ }
+
+ @NeverInline
+ public void bar() {
+ System.out.println("bar");
+ }
+ }
+
+ @NeverClassInline
+ public static class C {
+ B fieldB;
+ B[] fieldArrayB;
+
+ public C(B b) {
+ fieldB = b;
+ fieldArrayB = new B[] {b, b};
+ }
+
+ @NeverInline
+ public void foo() {
+ fieldB.bar();
+ for (B b : fieldArrayB) {
+ b.bar();
+ }
+ }
+ }
+
+ public static class Main {
+ public static void main(String[] args) {
+ new A();
+ B b = new B();
+ new C(b).foo();
+ }
+ }
+}
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 934c06f..959a42d 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
@@ -10,6 +10,7 @@
import com.android.tools.r8.graph.AccessFlags;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.naming.retrace.StackTrace;
import com.android.tools.r8.naming.retrace.StackTrace.StackTraceLine;
import com.android.tools.r8.references.MethodReference;
@@ -436,6 +437,52 @@
};
}
+ public static Matcher<FieldSubject> isFieldOfType(DexType type) {
+ return new TypeSafeMatcher<FieldSubject>() {
+ @Override
+ protected boolean matchesSafely(FieldSubject fieldSubject) {
+ return fieldSubject.getFieldReference().type == type;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("is field of type");
+ }
+
+ @Override
+ protected void describeMismatchSafely(FieldSubject item, Description mismatchDescription) {
+ mismatchDescription
+ .appendText(item.getOriginalSignature().toString())
+ .appendText(" is not of type ")
+ .appendText(type.toSourceString());
+ }
+ };
+ }
+
+ public static Matcher<FieldSubject> isFieldOfArrayType(
+ CodeInspector codeInspector, DexType type) {
+ return new TypeSafeMatcher<FieldSubject>() {
+ @Override
+ protected boolean matchesSafely(FieldSubject fieldSubject) {
+ return fieldSubject.getFieldReference().type.isArrayType()
+ && fieldSubject.getFieldReference().type.toBaseType(codeInspector.getFactory()) == type;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("is field of type");
+ }
+
+ @Override
+ protected void describeMismatchSafely(FieldSubject item, Description mismatchDescription) {
+ mismatchDescription
+ .appendText(item.getOriginalSignature().toString())
+ .appendText(" is not an array of type ")
+ .appendText(type.toSourceString());
+ }
+ };
+ }
+
public static Matcher<RetraceMethodResult> isInlineFrame() {
return new TypeSafeMatcher<RetraceMethodResult>() {
@Override
