Inline static methods preserving class initialization
When a class has a non-trivial <clinit> method, we used to forbid
inlining of any of its static methods to make sure that the
initialization of the class is preserved.
This CL relaxes that constraint when we can prove that the method
does preserve class initialization before anything else. That is to
say that the method will unconditionally execute an instruction that
triggers class initialization before any other side effect happens.
This improvement covers Kotlin accessor methods in companion classes.
These static methods are used to access properties of companion
classes which involves accessing a private static field in an outer
class. This CL also adds new test cases to verify that these Kotlin
accessor methods are inlined as expected when access relaxation is
enabled.
Bug: 70158739
Bug: 73518823
Change-Id: I079c2c8227ca085ee3637a9499dbef614baebc6f
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 4fdd8ac..0bd48bd 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -533,6 +533,7 @@
private boolean forceInline = false;
private boolean useIdentifierNameString = false;
private boolean checksNullReceiverBeforeAnySideEffect = false;
+ private boolean triggersClassInitBeforeAnySideEffect = false;
private OptimizationInfo() {
// Intentionally left empty.
@@ -586,6 +587,10 @@
return checksNullReceiverBeforeAnySideEffect;
}
+ public boolean triggersClassInitBeforeAnySideEffect() {
+ return triggersClassInitBeforeAnySideEffect;
+ }
+
private void markReturnsArgument(int argument) {
assert argument >= 0;
assert returnedArgument == -1 || returnedArgument == argument;
@@ -621,6 +626,10 @@
private void markCheckNullReceiverBeforeAnySideEffect(boolean mark) {
checksNullReceiverBeforeAnySideEffect = mark;
}
+
+ private void markTriggerClassInitBeforeAnySideEffect(boolean mark) {
+ triggersClassInitBeforeAnySideEffect = mark;
+ }
}
private static class DefaultOptimizationInfo extends OptimizationInfo {
@@ -671,6 +680,10 @@
ensureMutableOI().markCheckNullReceiverBeforeAnySideEffect(mark);
}
+ synchronized public void markTriggerClassInitBeforeAnySideEffect(boolean mark) {
+ ensureMutableOI().markTriggerClassInitBeforeAnySideEffect(mark);
+ }
+
public OptimizationInfo getOptimizationInfo() {
return optimizationInfo;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index 96dd131..c47dc54 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -1050,7 +1050,27 @@
throw new Unreachable("Instructions without outValue have no type.");
}
+ /**
+ * Indicates whether the instruction throws a NullPointerException if the object denoted by the
+ * given value is null at runtime execution.
+ *
+ * @param value the value representing an object that may be null at runtime execution.
+ * @return true if the instruction throws NullPointerException if value is null at runtime,
+ * false otherwise.
+ */
public boolean throwsNpeIfValueIsNull(Value value) {
return false;
}
+
+ /**
+ * Indicates whether the instruction triggers the class initialization (i.e. the <clinit> method)
+ * of the given class at runtime execution.
+ *
+ * @param klass a class of the program
+ * @return true if the instruction triggers intialization of the class at runtime, false
+ * otherwise.
+ */
+ public boolean triggersInitializationOfClass(DexType klass) {
+ return false;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
index 1867d14..e628f39 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
@@ -111,4 +111,9 @@
public void buildCf(CfBuilder builder) {
builder.add(new CfInvoke(Opcodes.INVOKESTATIC, getInvokedMethod()));
}
+
+ @Override
+ public boolean triggersInitializationOfClass(DexType klass) {
+ return getInvokedMethod().holder == klass;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
index ec8a2b0..ea6b208 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
@@ -104,4 +104,9 @@
AppInfo appInfo, Function<Value, TypeLatticeElement> getLatticeElement) {
return TypeLatticeElement.fromDexType(clazz, false);
}
+
+ @Override
+ public boolean triggersInitializationOfClass(DexType klass) {
+ return clazz == klass;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
index 59d1054..47141bc 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
@@ -144,4 +144,9 @@
AppInfo appInfo, Function<Value, TypeLatticeElement> getLatticeElement) {
return TypeLatticeElement.fromDexType(field.type, true);
}
+
+ @Override
+ public boolean triggersInitializationOfClass(DexType klass) {
+ return field.clazz == klass;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
index cd8acc2..0eca18d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
@@ -132,4 +132,9 @@
public void buildCf(CfBuilder builder) {
builder.add(new CfFieldInstruction(Opcodes.PUTSTATIC, field));
}
+
+ @Override
+ public boolean triggersInitializationOfClass(DexType klass) {
+ return field.clazz == klass;
+ }
}
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 f9bcf1d..9a3a218 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
@@ -654,7 +654,9 @@
codeRewriter.useDedicatedConstantForLitInstruction(code);
codeRewriter.shortenLiveRanges(code);
codeRewriter.identifyReturnsArgument(method, code, feedback);
- codeRewriter.identifyReceiverNullabilityChecks(method, code, feedback);
+ if (options.enableInlining && inliner != null) {
+ codeRewriter.identifyInvokeSemanticsForInlining(method, code, feedback);
+ }
// Insert code to log arguments if requested.
if (options.methodMatchesLogArgumentsFilter(method)) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
index 1b29233..b2c5cfd 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
@@ -14,4 +14,5 @@
void methodNeverReturnsNormally(DexEncodedMethod method);
void markProcessed(DexEncodedMethod method, Constraint state);
void markCheckNullReceiverBeforeAnySideEffect(DexEncodedMethod method, boolean mark);
+ void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
index 1fd3a2f..ac1972b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
@@ -38,4 +38,9 @@
public void markCheckNullReceiverBeforeAnySideEffect(DexEncodedMethod method, boolean mark) {
method.markCheckNullReceiverBeforeAnySideEffect(mark);
}
+
+ @Override
+ public void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark) {
+ method.markTriggerClassInitBeforeAnySideEffect(mark);
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
index e409818..80cb04f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
@@ -26,4 +26,7 @@
@Override
public void markCheckNullReceiverBeforeAnySideEffect(DexEncodedMethod method, boolean mark) {}
+
+ @Override
+ public void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark) {}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 069f67c..3dc38c6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -97,11 +97,13 @@
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
+import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
+import java.util.function.Function;
import java.util.function.Predicate;
public class CodeRewriter {
@@ -709,22 +711,105 @@
}
}
- public void identifyReceiverNullabilityChecks(
+ public void identifyInvokeSemanticsForInlining(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
- if (!method.isStaticMethod()) {
+ if (method.isStaticMethod()) {
+ // Identifies if the method preserves class initialization after inlining.
+ feedback.markTriggerClassInitBeforeAnySideEffect(method,
+ triggersClassInitializationBeforeSideEffect(code, method.method.getHolder()));
+ } else {
+ // Identifies if the method preserves null check of the receiver after inlining.
final Value receiver = code.getThis();
feedback.markCheckNullReceiverBeforeAnySideEffect(method,
- receiver.isUsed() && allPathsCheckNullReceiverBeforeSideEffect(code, receiver));
+ receiver.isUsed() && checksNullReceiverBeforeSideEffect(code, receiver));
}
}
/**
+ * An enum used to classify instructions according to a particular effect that they produce.
+ *
+ * The "effect" of an instruction can be seen as a program state change (or semantic change) at
+ * runtime execution. For example, an instruction could cause the initialization of a class,
+ * change the value of a field, ... while other instructions do not.
+ *
+ * This classification also depends on the type of analysis that is using it. For instance, an
+ * analysis can look for instructions that cause class initialization while another look for
+ * instructions that check nullness of a particular object.
+ *
+ * On the other hand, some instructions may provide a non desired effect which is a signal for
+ * the analysis to stop.
+ */
+ private enum InstructionEffect {
+ DESIRED_EFFECT,
+ OTHER_EFFECT,
+ NO_EFFECT
+ }
+
+ /**
* Returns true if the given code unconditionally throws if receiver is null before any other
* side effect instruction.
*
* Note: we do not track phis so we may return false negative. This is a conservative approach.
*/
- private static boolean allPathsCheckNullReceiverBeforeSideEffect(IRCode code, Value receiver) {
+ private static boolean checksNullReceiverBeforeSideEffect(IRCode code, Value receiver) {
+ return alwaysTriggerExpectedEffectBeforeAnythingElse(code, instr -> {
+ if (instr.throwsNpeIfValueIsNull(receiver)) {
+ // In order to preserve NPE semantic, the exception must not be caught by any handler.
+ // Therefore, we must ignore this instruction if it is covered by a catch handler.
+ // Note: this is a conservative approach where we consider that any catch handler could
+ // catch the exception, even if it cannot catch a NullPointerException.
+ if (!instr.getBlock().hasCatchHandlers()) {
+ // We found a NPE check on receiver.
+ return InstructionEffect.DESIRED_EFFECT;
+ }
+ } else if (instructionHasSideEffects(instr)) {
+ // We found a side effect before a NPE check.
+ return InstructionEffect.OTHER_EFFECT;
+ }
+ return InstructionEffect.NO_EFFECT;
+ });
+ }
+
+ private static boolean instructionHasSideEffects(Instruction instruction) {
+ // We consider that an instruction has side effects if it can throw an exception. This is a
+ // conservative approach which can be revised in the future.
+ return instruction.instructionTypeCanThrow();
+ }
+
+ /**
+ * Returns true if the given code unconditionally triggers class initialization before any other
+ * side effecting instruction.
+ *
+ * Note: we do not track phis so we may return false negative. This is a conservative approach.
+ */
+ private static boolean triggersClassInitializationBeforeSideEffect(IRCode code, DexType klass) {
+ return alwaysTriggerExpectedEffectBeforeAnythingElse(code, instruction -> {
+ if (instruction.triggersInitializationOfClass(klass)) {
+ // In order to preserve class initialization semantic, the exception must not be caught by
+ // any handler. Therefore, we must ignore this instruction if it is covered by a catch
+ // handler.
+ // Note: this is a conservative approach where we consider that any catch handler could
+ // catch the exception, even if it cannot catch an ExceptionInInitializerError.
+ if (!instruction.getBlock().hasCatchHandlers()) {
+ // We found an instruction that preserves initialization of the class.
+ return InstructionEffect.DESIRED_EFFECT;
+ }
+ } else if (instructionHasSideEffects(instruction)) {
+ // We found a side effect before class initialization.
+ return InstructionEffect.OTHER_EFFECT;
+ }
+ return InstructionEffect.NO_EFFECT;
+ });
+ }
+
+ /**
+ * Returns true if the given code unconditionally triggers an expected effect before anything
+ * else, false otherwise.
+ *
+ * Note: we do not track phis so we may return false negative. This is a conservative approach.
+ */
+ private static boolean alwaysTriggerExpectedEffectBeforeAnythingElse(IRCode code,
+ Function<Instruction, InstructionEffect> function) {
final int color = code.reserveMarkingColor();
try {
ArrayDeque<BasicBlock> worklist = new ArrayDeque<>();
@@ -736,34 +821,25 @@
BasicBlock currentBlock = worklist.poll();
assert currentBlock.isMarked(color);
- boolean foundNullCheckBeforeSideEffect = false;
- for (Instruction instr : currentBlock.getInstructions()) {
- if (instr.throwsNpeIfValueIsNull(receiver)) {
- // In order to preserve NPE semantic, the exception must not be caught by any handler.
- // Therefore, we must ignore this instruction if it is covered by a catch handler.
- // Note: this is a conservative approach where we consider that any catch handler could
- // catch the exception, even if it cannot catch a NullPointerException.
- if (!currentBlock.hasCatchHandlers()) {
- // We found a NPE check on receiver
- foundNullCheckBeforeSideEffect = true;
- break;
- }
- } else if (instructionHasSideEffects(instr)) {
- // We found a side effect before a NPE check.
- return false;
- }
+ InstructionEffect result = InstructionEffect.NO_EFFECT;
+ Iterator<Instruction> it = currentBlock.listIterator();
+ while (result == InstructionEffect.NO_EFFECT && it.hasNext()) {
+ result = function.apply(it.next());
}
-
- if (foundNullCheckBeforeSideEffect) {
- // The current path checks NPE. No need to go deeper in this path, go to the next block
- // in the work list.
+ if (result == InstructionEffect.OTHER_EFFECT) {
+ // We found an instruction that is causing an unexpected side effect.
+ return false;
+ } else if (result == InstructionEffect.DESIRED_EFFECT) {
+ // The current path is causing the expected effect. No need to go deeper in this path,
+ // go to the next block in the work list.
continue;
} else {
- // The block neither checked NPE nor had side effect.
+ assert result == InstructionEffect.NO_EFFECT;
+ // The block did not cause any particular effect.
if (currentBlock.getNormalSuccessors().isEmpty()) {
- // This is the end of the current non-exceptional path and we did not find any null
- // check of the receiver. It means there is at least one path where the receiver is not
- // checked for null.
+ // This is the end of the current non-exceptional path and we did not find any expected
+ // effect. It means there is at least one path where the expected effect does not
+ // happen.
Instruction lastInstruction = currentBlock.getInstructions().getLast();
assert lastInstruction.isReturn() || lastInstruction.isThrow();
return false;
@@ -779,19 +855,13 @@
}
}
- // If we reach this point, we checked the null receiver in every possible path.
+ // If we reach this point, we checked that the expected effect happens in every possible path.
return true;
} finally {
code.returnMarkingColor(color);
}
}
- private static boolean instructionHasSideEffects(Instruction instruction) {
- // We consider that an instruction has side effects if it can throw an exception. This is a
- // conservative approach which can be revised in the future.
- return instruction.instructionTypeCanThrow();
- }
-
private boolean checkArgumentType(InvokeMethod invoke, DexMethod target, int argumentIndex) {
DexType returnType = invoke.getInvokedMethod().proto.returnType;
// TODO(sgjesse): Insert cast if required.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
index fde6293..7947c01 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
@@ -97,11 +97,18 @@
private boolean canInlineStaticInvoke(DexEncodedMethod method, DexEncodedMethod target) {
// Only proceed with inlining a static invoke if:
// - the holder for the target equals the holder for the method, or
- // - there is no class initializer.
+ // - the target method always triggers class initialization of its holder before any other side
+ // effect (hence preserving class initialization semantics).
+ // - there is no non-trivial class initializer.
DexType targetHolder = target.method.getHolder();
if (method.method.getHolder() == targetHolder) {
return true;
}
+ DexClass clazz = inliner.appInfo.definitionFor(targetHolder);
+ assert clazz != null;
+ if (target.getOptimizationInfo().triggersClassInitBeforeAnySideEffect()) {
+ return true;
+ }
return classInitializationHasNoSideffects(targetHolder);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
new file mode 100644
index 0000000..82e6cd0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -0,0 +1,240 @@
+// 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.kotlin;
+
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.jasmin.JasminBuilder;
+import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
+import com.android.tools.r8.kotlin.KotlinClass.Visibility;
+import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DexInspector;
+import com.android.tools.r8.utils.DexInspector.ClassSubject;
+import com.android.tools.r8.utils.DexInspector.FieldSubject;
+import java.nio.file.Path;
+import java.util.Collections;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class R8KotlinAccessorTest extends AbstractR8KotlinTestBase {
+
+ private static final String JAVA_LANG_STRING = "java.lang.String";
+
+ private static final KotlinCompanionClass ACCESSOR_COMPANION_PROPERTY_CLASS =
+ new KotlinCompanionClass("accessors.Accessor")
+ .addProperty("property", JAVA_LANG_STRING, Visibility.PRIVATE);
+
+ private static final String PROPERTIES_PACKAGE_NAME = "properties";
+
+ private static final KotlinCompanionClass COMPANION_PROPERTY_CLASS =
+ new KotlinCompanionClass("properties.CompanionProperties")
+ .addProperty("privateProp", JAVA_LANG_STRING, Visibility.PRIVATE)
+ .addProperty("protectedProp", JAVA_LANG_STRING, Visibility.PROTECTED)
+ .addProperty("internalProp", JAVA_LANG_STRING, Visibility.INTERNAL)
+ .addProperty("publicProp", JAVA_LANG_STRING, Visibility.PUBLIC)
+ .addProperty("primitiveProp", "int", Visibility.PUBLIC);
+
+ @Test
+ public void testCompanionProperty_primitivePropertyIsAlwaysInlined() throws Exception {
+ String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
+ "companionProperties_usePrimitiveProp");
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
+ DexInspector dexInspector = new DexInspector(app);
+ ClassSubject outerClass = checkClassExists(dexInspector,
+ COMPANION_PROPERTY_CLASS.getOuterClassName());
+ String propertyName = "primitiveProp";
+ FieldSubject fieldSubject = checkFieldIsPresent(outerClass, "int", propertyName);
+ assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+ MemberNaming.MethodSignature getterAccessor =
+ new MemberNaming.MethodSignature("access$getPrimitiveProp$cp", "int",
+ Collections.emptyList());
+ MemberNaming.MethodSignature setterAccessor =
+ new MemberNaming.MethodSignature("access$setPrimitiveProp$cp", "void",
+ Collections.singletonList("int"));
+
+ if (allowAccessModification) {
+ assertTrue(fieldSubject.getField().accessFlags.isPublic());
+ checkMethodIsAbsent(outerClass, getterAccessor);
+ checkMethodIsAbsent(outerClass, setterAccessor);
+ } else {
+ assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+ checkMethodIsPresent(outerClass, getterAccessor);
+ checkMethodIsPresent(outerClass, setterAccessor);
+ }
+ });
+ }
+
+ @Test
+ public void testCompanionProperty_privatePropertyIsAlwaysInlined() throws Exception {
+ String mainClass = addMainToClasspath(
+ "properties.CompanionPropertiesKt", "companionProperties_usePrivateProp");
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
+ DexInspector dexInspector = new DexInspector(app);
+ ClassSubject outerClass = checkClassExists(dexInspector,
+ COMPANION_PROPERTY_CLASS.getOuterClassName());
+ String propertyName = "privateProp";
+ FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+ assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+ MemberNaming.MethodSignature getterAccessor =
+ new MemberNaming.MethodSignature("access$getPrivateProp$cp", JAVA_LANG_STRING,
+ Collections.emptyList());
+ MemberNaming.MethodSignature setterAccessor =
+ new MemberNaming.MethodSignature("access$setPrivateProp$cp", "void",
+ Collections.singletonList(JAVA_LANG_STRING));
+ if (allowAccessModification) {
+ assertTrue(fieldSubject.getField().accessFlags.isPublic());
+
+ checkMethodIsAbsent(outerClass, getterAccessor);
+ checkMethodIsAbsent(outerClass, setterAccessor);
+ } else {
+ assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+
+ checkMethodIsPresent(outerClass, getterAccessor);
+ checkMethodIsPresent(outerClass, setterAccessor);
+ }
+ });
+ }
+
+ @Test
+ public void testCompanionProperty_internalPropertyIsAlwaysInlined() throws Exception {
+ String mainClass = addMainToClasspath(
+ "properties.CompanionPropertiesKt", "companionProperties_useInternalProp");
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
+ DexInspector dexInspector = new DexInspector(app);
+ ClassSubject outerClass = checkClassExists(dexInspector,
+ COMPANION_PROPERTY_CLASS.getOuterClassName());
+ String propertyName = "internalProp";
+ FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+ assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+ MemberNaming.MethodSignature getterAccessor =
+ new MemberNaming.MethodSignature("access$getInternalProp$cp", JAVA_LANG_STRING,
+ Collections.emptyList());
+ MemberNaming.MethodSignature setterAccessor =
+ new MemberNaming.MethodSignature("access$setInternalProp$cp", "void",
+ Collections.singletonList(JAVA_LANG_STRING));
+
+ if (allowAccessModification) {
+ assertTrue(fieldSubject.getField().accessFlags.isPublic());
+ checkMethodIsAbsent(outerClass, getterAccessor);
+ checkMethodIsAbsent(outerClass, setterAccessor);
+ } else {
+ assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+ checkMethodIsPresent(outerClass, getterAccessor);
+ checkMethodIsPresent(outerClass, setterAccessor);
+ }
+ });
+ }
+
+ @Test
+ public void testCompanionProperty_publicPropertyIsAlwaysInlined() throws Exception {
+ String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
+ "companionProperties_usePublicProp");
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
+ DexInspector dexInspector = new DexInspector(app);
+ ClassSubject outerClass = checkClassExists(dexInspector,
+ COMPANION_PROPERTY_CLASS.getOuterClassName());
+ String propertyName = "publicProp";
+ FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+ assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+ MemberNaming.MethodSignature getterAccessor =
+ new MemberNaming.MethodSignature("access$getPublicProp$cp", JAVA_LANG_STRING,
+ Collections.emptyList());
+ MemberNaming.MethodSignature setterAccessor =
+ new MemberNaming.MethodSignature("access$setPublicProp$cp", "void",
+ Collections.singletonList(JAVA_LANG_STRING));
+
+ if (allowAccessModification) {
+ assertTrue(fieldSubject.getField().accessFlags.isPublic());
+ checkMethodIsAbsent(outerClass, getterAccessor);
+ checkMethodIsAbsent(outerClass, setterAccessor);
+ } else {
+ assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+ checkMethodIsPresent(outerClass, getterAccessor);
+ checkMethodIsPresent(outerClass, setterAccessor);
+ }
+ });
+ }
+
+ @Test
+ public void testAccessor() throws Exception {
+ String mainClass = addMainToClasspath("accessors.AccessorKt",
+ "accessor_accessCompanionPrivate");
+ runTest("accessors", mainClass, (app) -> {
+ DexInspector dexInspector = new DexInspector(app);
+ KotlinCompanionClass testedClass = ACCESSOR_COMPANION_PROPERTY_CLASS;
+ ClassSubject outerClass = checkClassExists(dexInspector,
+ testedClass.getOuterClassName());
+ ClassSubject companionClass = checkClassExists(dexInspector,
+ testedClass.getClassName());
+ String propertyName = "property";
+ FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+ assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+ // The getter is always inlined since it just calls into the accessor.
+ MemberNaming.MethodSignature getter = testedClass
+ .getGetterForProperty(propertyName);
+ checkMethodIsAbsent(companionClass, getter);
+
+ MemberNaming.MethodSignature getterAccessor =
+ new MemberNaming.MethodSignature("access$getProperty$cp", JAVA_LANG_STRING,
+ Collections.emptyList());
+ if (allowAccessModification) {
+ assertTrue(fieldSubject.getField().accessFlags.isPublic());
+ checkMethodIsAbsent(outerClass, getterAccessor);
+ } else {
+ assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+ checkMethodIsPresent(outerClass, getterAccessor);
+ }
+ });
+ }
+
+ @Test
+ public void testStaticFieldAccessorWithJasmin() throws Exception {
+ JasminBuilder jasminBuilder = new JasminBuilder();
+ ClassBuilder classBuilder = jasminBuilder.addClass("Foo");
+ classBuilder.addDefaultConstructor();
+ classBuilder.addStaticField("aField", "I", "5");
+ classBuilder.addMainMethod(
+ ".limit stack 1",
+ "invokestatic Foo$Inner/readField()V",
+ "return"
+ );
+ classBuilder.addStaticMethod("access$field", Collections.emptyList(), "I",
+ ".limit stack 1",
+ "getstatic Foo.aField I",
+ "ireturn");
+
+ classBuilder = jasminBuilder.addClass("Foo$Inner");
+ classBuilder.addDefaultConstructor();
+ classBuilder.addStaticMethod("readField", Collections.emptyList(), "V",
+ ".limit stack 2",
+ "getstatic java/lang/System.out Ljava/io/PrintStream;",
+ "invokestatic Foo/access$field()I",
+ "invokevirtual java/io/PrintStream/println(I)V",
+ "return"
+ );
+
+ Path javaOutput = writeToZip(jasminBuilder);
+ ProcessResult javaResult = ToolHelper.runJava(javaOutput, "Foo");
+ if (javaResult.exitCode != 0) {
+ System.err.println(javaResult.stderr);
+ Assert.fail();
+ } else {
+ System.out.println(javaResult.stdout);
+ }
+
+ AndroidApp app = compileWithR8(jasminBuilder.build(),
+ keepMainProguardConfiguration("Foo") + "\ndontobfuscate");
+ String artOutput = runOnArt(app, "Foo");
+ System.out.println(artOutput);
+ }
+}
diff --git a/src/test/kotlinR8TestResources/accessors/Accessor.kt b/src/test/kotlinR8TestResources/accessors/Accessor.kt
new file mode 100644
index 0000000..e88a055
--- /dev/null
+++ b/src/test/kotlinR8TestResources/accessors/Accessor.kt
@@ -0,0 +1,19 @@
+// 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 accessors
+
+class Accessor {
+ companion object {
+ private val property = "foo"
+
+ fun printProperty() {
+ println(property)
+ }
+ }
+}
+
+fun accessor_accessCompanionPrivate() {
+ Accessor.printProperty()
+}
\ No newline at end of file
diff --git a/src/test/kotlinR8TestResources/accessors/CompanionProperties.kt b/src/test/kotlinR8TestResources/accessors/CompanionProperties.kt
new file mode 100644
index 0000000..cd3cffc
--- /dev/null
+++ b/src/test/kotlinR8TestResources/accessors/CompanionProperties.kt
@@ -0,0 +1,30 @@
+// 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 accessors
+
+class CompanionProperties {
+ companion object {
+ private var privateProp: String = "privateProp"
+ }
+
+ fun callSetterPrivateProp(v: String) {
+ privateProp = v
+ }
+
+ fun callGetterPrivateProp(): String {
+ return privateProp
+ }
+}
+
+fun companionProperties_noUseOfProperties() {
+ CompanionProperties()
+ println("DONE")
+}
+
+fun companionProperties_usePrivatePropFromOuter() {
+ val obj = CompanionProperties()
+ obj.callSetterPrivateProp("foo")
+ println(obj.callGetterPrivateProp())
+}
