Enum unboxing: improve enum instance state tracking
Bug: 155368026
Change-Id: Iac3057cad74510f20a4a955a9dc538e7996a8691
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 3d8df1a..ebcdfff 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.EnumValuesObjectState;
import com.android.tools.r8.ir.analysis.value.ObjectState;
import com.android.tools.r8.ir.analysis.value.SingleFieldValue;
import com.android.tools.r8.ir.code.ArrayPut;
@@ -25,6 +26,7 @@
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.NewArrayEmpty;
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
@@ -141,9 +143,132 @@
* array as long as the array is identified as being the {@code $VALUES} array.
*/
private SingleFieldValue computeSingleEnumFieldValue(Value value) {
+ if (!context.getHolder().isEnum()) {
+ return null;
+ }
assert !value.hasAliasedValue();
- if (!context.getHolder().isEnum()
- || !value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
+ if (isEnumValuesArray(value)) {
+ return computeSingleEnumFieldValueForValuesArray(value);
+ }
+ return computeSingleEnumFieldValueForInstance(value);
+ }
+
+ private SingleFieldValue computeSingleEnumFieldValueForValuesArray(Value value) {
+ if (!value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty)) {
+ return null;
+ }
+
+ NewArrayEmpty newArrayEmpty = value.definition.asNewArrayEmpty();
+ if (newArrayEmpty.type.toBaseType(appView.dexItemFactory()) != context.getHolder().type) {
+ return null;
+ }
+ if (value.hasDebugUsers() || value.hasPhiUsers()) {
+ return null;
+ }
+ if (!newArrayEmpty.size().isConstNumber()) {
+ return null;
+ }
+
+ int valuesSize = newArrayEmpty.size().getConstInstruction().asConstNumber().getIntValue();
+ if (valuesSize == 0) {
+ // No need to compute the state of an empty array.
+ return null;
+ }
+
+ ObjectState[] valuesState = new ObjectState[valuesSize];
+ DexEncodedField valuesField = null;
+ for (Instruction user : value.uniqueUsers()) {
+ switch (user.opcode()) {
+ case ARRAY_PUT:
+ ArrayPut arrayPut = user.asArrayPut();
+ if (arrayPut.array() != value) {
+ return null;
+ }
+ if (!arrayPut.index().isConstNumber()) {
+ return null;
+ }
+ int index = arrayPut.index().getConstInstruction().asConstNumber().getIntValue();
+ if (index < 0 || index >= valuesSize) {
+ return null;
+ }
+ ObjectState objectState = computeEnumInstanceObjectState(arrayPut.value());
+ if (objectState == null || objectState.isEmpty()) {
+ // We need the state of all fields for the analysis to be valuable.
+ return null;
+ }
+ assert verifyValuesArrayIndexMatchesOrdinal(index, objectState);
+ if (valuesState[index] != null) {
+ return null;
+ }
+ valuesState[index] = objectState;
+ break;
+
+ case STATIC_PUT:
+ DexEncodedField field =
+ context.getHolder().lookupStaticField(user.asStaticPut().getField());
+ if (field == null) {
+ return null;
+ }
+ if (valuesField != null) {
+ return null;
+ }
+ valuesField = field;
+ break;
+
+ default:
+ return null;
+ }
+ }
+
+ if (valuesField == null) {
+ return null;
+ }
+
+ for (ObjectState objectState : valuesState) {
+ if (objectState == null) {
+ return null;
+ }
+ }
+
+ return appView
+ .abstractValueFactory()
+ .createSingleFieldValue(valuesField.field, new EnumValuesObjectState(valuesState));
+ }
+
+ private ObjectState computeEnumInstanceObjectState(Value value) {
+ Value root = value.getAliasedValue();
+ if (root.isPhi()) {
+ return ObjectState.empty();
+ }
+ Instruction definition = root.getDefinition();
+ if (definition.isNewInstance()) {
+ return computeObjectState(definition.outValue());
+ }
+ if (definition.isStaticGet()) {
+ // TODO(b/166532388) : Enums with many instance rely on staticGets to set the $VALUES data
+ // instead of directly keeping the values in registers. We could consider analysing these
+ // and answer the analysed object state here.
+ return ObjectState.empty();
+ }
+ return ObjectState.empty();
+ }
+
+ private boolean verifyValuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
+ DexEncodedField ordinalField =
+ appView
+ .appInfo()
+ .resolveField(appView.dexItemFactory().enumMembers.ordinalField, context)
+ .getResolvedField();
+ assert ordinalField != null;
+ AbstractValue ordinalState = objectState.getAbstractFieldValue(ordinalField);
+ assert ordinalState != null;
+ assert ordinalState.isSingleNumberValue();
+ assert ordinalState.asSingleNumberValue().getIntValue() == ordinal;
+ return true;
+ }
+
+ private SingleFieldValue computeSingleEnumFieldValueForInstance(Value value) {
+ if (!value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java b/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java
new file mode 100644
index 0000000..f1ec89c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java
@@ -0,0 +1,82 @@
+// 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.ir.analysis.value;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Arrays;
+import java.util.Objects;
+
+public class EnumValuesObjectState extends ObjectState {
+
+ private final ObjectState[] state;
+
+ public EnumValuesObjectState(ObjectState[] state) {
+ assert state.length > 0;
+ assert Arrays.stream(state).noneMatch(Objects::isNull);
+ this.state = state;
+ }
+
+ @Override
+ public AbstractValue getAbstractFieldValue(DexEncodedField field) {
+ return UnknownValue.getInstance();
+ }
+
+ public ObjectState getObjectStateForOrdinal(int ordinal) {
+ if (ordinal < 0 || ordinal >= state.length) {
+ return ObjectState.empty();
+ }
+ return state[ordinal];
+ }
+
+ @Override
+ public boolean isEnumValuesObjectState() {
+ return true;
+ }
+
+ @Override
+ public EnumValuesObjectState asEnumValuesObjectState() {
+ return this;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ // Non-empty by construction.
+ return false;
+ }
+
+ @Override
+ public ObjectState rewrittenWithLens(AppView<AppInfoWithLiveness> appView, GraphLens lens) {
+ ObjectState[] newState = new ObjectState[state.length];
+ for (int i = 0; i < state.length; i++) {
+ newState[i] = state[i].rewrittenWithLens(appView, lens);
+ }
+ return new EnumValuesObjectState(newState);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (getClass() != o.getClass()) {
+ return false;
+ }
+ EnumValuesObjectState other = (EnumValuesObjectState) o;
+ if (state.length != other.state.length) {
+ return false;
+ }
+ for (int i = 0; i < state.length; i++) {
+ if (!state[i].equals(other.state[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return Arrays.hashCode(state);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java b/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
index b724858..4e6d970 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
@@ -35,6 +35,14 @@
@Override
public abstract int hashCode();
+ public boolean isEnumValuesObjectState() {
+ return false;
+ }
+
+ public EnumValuesObjectState asEnumValuesObjectState() {
+ return null;
+ }
+
public static class Builder {
private final Map<DexField, AbstractValue> state = new IdentityHashMap<>();
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
index 0cb75c3..98a7fa4 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
@@ -50,6 +50,10 @@
return value;
}
+ public int getIntValue() {
+ return (int) value;
+ }
+
@Override
public boolean equals(Object o) {
return this == o;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index dac0f6d..8fafcb7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -994,33 +994,32 @@
private EnumInstanceFieldData computeEnumFieldData(
DexField instanceField, DexProgramClass enumClass) {
- EnumValueInfoMapCollection.EnumValueInfoMap enumValueInfoMap =
- appView.appInfo().getEnumValueInfoMap(enumClass.type);
DexEncodedField encodedInstanceField =
appView.appInfo().resolveFieldOn(enumClass, instanceField).getResolvedField();
assert encodedInstanceField != null;
boolean canBeOrdinal = instanceField.type.isIntType();
Map<DexField, AbstractValue> data = new IdentityHashMap<>();
+ EnumValueInfoMapCollection.EnumValueInfoMap enumValueInfoMap =
+ appView.appInfo().getEnumValueInfoMap(enumClass.type);
for (DexField staticField : enumValueInfoMap.enumValues()) {
- DexEncodedField encodedStaticField = enumClass.lookupStaticField(staticField);
- AbstractValue enumInstanceValue = encodedStaticField.getOptimizationInfo().getAbstractValue();
- // TODO(b/155368026): Support other constants than Number and String, so far we support only
- // these two because they're the most common and we don't have to deal with accessibility.
- if (!enumInstanceValue.isSingleFieldValue()) {
- return EnumInstanceFieldUnknownData.getInstance();
- }
- ObjectState enumInstanceState = enumInstanceValue.asSingleFieldValue().getState();
- AbstractValue fieldValue = enumInstanceState.getAbstractFieldValue(encodedInstanceField);
- if (!(fieldValue.isSingleNumberValue() || fieldValue.isSingleStringValue())) {
- return EnumInstanceFieldUnknownData.getInstance();
- }
- data.put(staticField, fieldValue);
- if (canBeOrdinal) {
- int ordinalValue = enumValueInfoMap.getEnumValueInfo(staticField).ordinal;
- assert fieldValue.isSingleNumberValue();
- int computedValue = (int) fieldValue.asSingleNumberValue().getValue();
- if (computedValue != ordinalValue) {
- canBeOrdinal = false;
+ ObjectState enumInstanceState =
+ computeEnumInstanceObjectState(enumClass, staticField, enumValueInfoMap);
+ if (enumInstanceState == null) {
+ // The enum instance is effectively unused. No need to generate anything for it, the path
+ // will never be taken.
+ } else {
+ AbstractValue fieldValue = enumInstanceState.getAbstractFieldValue(encodedInstanceField);
+ if (!(fieldValue.isSingleNumberValue() || fieldValue.isSingleStringValue())) {
+ return EnumInstanceFieldUnknownData.getInstance();
+ }
+ data.put(staticField, fieldValue);
+ if (canBeOrdinal) {
+ int ordinalValue = enumValueInfoMap.getEnumValueInfo(staticField).ordinal;
+ assert fieldValue.isSingleNumberValue();
+ int computedValue = fieldValue.asSingleNumberValue().getIntValue();
+ if (computedValue != ordinalValue) {
+ canBeOrdinal = false;
+ }
}
}
}
@@ -1030,6 +1029,52 @@
return new EnumInstanceFieldMappingData(data);
}
+ // We need to access the enum instance object state to figure out if it contains known constant
+ // field values. The enum instance may be accessed in two ways, directly through the enum
+ // static field, or through the enum $VALUES field. If none of them are kept, the instance is
+ // effectively unused. The object state may be stored in the enum static field optimization
+ // info, if kept, or in the $VALUES optimization info, if kept.
+ // If the enum instance is unused, this method answers null.
+ private ObjectState computeEnumInstanceObjectState(
+ DexProgramClass enumClass,
+ DexField staticField,
+ EnumValueInfoMapCollection.EnumValueInfoMap enumValueInfoMap) {
+ // Attempt 1: Get object state from the instance field's optimization info.
+ DexEncodedField encodedStaticField = enumClass.lookupStaticField(staticField);
+ AbstractValue enumInstanceValue = encodedStaticField.getOptimizationInfo().getAbstractValue();
+ if (enumInstanceValue.isSingleFieldValue()) {
+ return enumInstanceValue.asSingleFieldValue().getState();
+ }
+ if (enumInstanceValue.isUnknown()) {
+ return ObjectState.empty();
+ }
+ assert enumInstanceValue.isZero();
+
+ // Attempt 2: Get object state from the values field's optimization info.
+ DexEncodedField valuesField =
+ enumClass.lookupStaticField(
+ factory.createField(
+ enumClass.type,
+ factory.createArrayType(1, enumClass.type),
+ factory.enumValuesFieldName));
+ AbstractValue valuesValue = valuesField.getOptimizationInfo().getAbstractValue();
+ if (valuesValue.isZero()) {
+ // Unused enum instance.
+ return null;
+ }
+ if (valuesValue.isUnknown()) {
+ return ObjectState.empty();
+ }
+ assert valuesValue.isSingleFieldValue();
+ ObjectState valuesState = valuesValue.asSingleFieldValue().getState();
+ if (valuesState.isEnumValuesObjectState()) {
+ return valuesState
+ .asEnumValuesObjectState()
+ .getObjectStateForOrdinal(enumValueInfoMap.getEnumValueInfo(staticField).ordinal);
+ }
+ return ObjectState.empty();
+ }
+
private boolean isFirstInstructionAfterArguments(InvokeMethod invokeMethod, IRCode code) {
BasicBlock basicBlock = code.entryBlock();
for (Instruction instruction : basicBlock.getInstructions()) {
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
index f2f0a06..8b35793 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
@@ -46,6 +46,7 @@
// TODO(b/155368026): Support fields and const class fields.
// Move this to something similar than SingleValue#createMaterializingInstruction
if (value.isSingleStringValue()) {
+ assert returnType == appView.dexItemFactory().stringType;
instructions.add(new CfConstString(value.asSingleStringValue().getDexString()));
} else if (value.isSingleNumberValue()) {
instructions.add(
@@ -88,14 +89,16 @@
// if (i == 2) { return 20;}
enumValueInfoMap.forEach(
(field, enumValueInfo) -> {
- CfLabel dest = new CfLabel();
- instructions.add(new CfLoad(ValueType.fromDexType(factory.intType), 0));
- instructions.add(new CfConstNumber(enumValueInfo.convertToInt(), ValueType.INT));
- instructions.add(new CfIfCmp(If.Type.NE, ValueType.INT, dest));
AbstractValue value = fieldDataMap.getData(field);
- addCfInstructionsForAbstractValue(instructions, value, returnType);
- instructions.add(new CfReturn(ValueType.fromDexType(returnType)));
- instructions.add(dest);
+ if (value != null) {
+ CfLabel dest = new CfLabel();
+ instructions.add(new CfLoad(ValueType.fromDexType(factory.intType), 0));
+ instructions.add(new CfConstNumber(enumValueInfo.convertToInt(), ValueType.INT));
+ instructions.add(new CfIfCmp(If.Type.NE, ValueType.INT, dest));
+ addCfInstructionsForAbstractValue(instructions, value, returnType);
+ instructions.add(new CfReturn(ValueType.fromDexType(returnType)));
+ instructions.add(dest);
+ }
});
// throw null;
@@ -155,7 +158,7 @@
CfLabel dest = new CfLabel();
instructions.add(new CfLoad(ValueType.fromDexType(factory.stringType), 0));
AbstractValue value = fieldDataMap.getData(field);
- addCfInstructionsForAbstractValue(instructions, value, factory.intType);
+ addCfInstructionsForAbstractValue(instructions, value, factory.stringType);
instructions.add(
new CfInvoke(Opcodes.INVOKEVIRTUAL, factory.stringMembers.equals, false));
instructions.add(new CfIf(If.Type.EQ, ValueType.INT, dest));
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
new file mode 100644
index 0000000..ddc0806
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
@@ -0,0 +1,75 @@
+// 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+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 EmptyEnumUnboxingTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final EnumKeepRules enumKeepRules;
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public EmptyEnumUnboxingTest(
+ TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ R8TestRunResult run =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(EmptyEnumUnboxingTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepRules(enumKeepRules.getKeepRules())
+ .enableNeverClassInliningAnnotations()
+ .enableInliningAnnotations()
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .allowDiagnosticInfoMessages()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspectDiagnosticMessages(
+ m ->
+ // TODO(b/166532373): Unbox enum with no cases.
+ assertEnumIsBoxed(MyEnum.class, Main.class.getSimpleName(), m))
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccess();
+ assertLines2By2Correct(run.getStdOut());
+ }
+
+ @NeverClassInline
+ enum MyEnum {
+ ;
+
+ @NeverInline
+ static void print() {
+ System.out.println("PRINT");
+ }
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ MyEnum.print();
+ System.out.println("PRINT");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
index 0c51e9d..590cc7c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
@@ -52,7 +52,7 @@
.addKeepRules(enumKeepRules.getKeepRules())
.addOptionsModification(
options -> {
- options.enableEnumUnboxing = true;
+ assert options.enableEnumUnboxing;
options.testing.enableEnumUnboxingDebugLogs = true;
})
.allowDiagnosticMessages()
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
new file mode 100644
index 0000000..a6b7027
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
@@ -0,0 +1,98 @@
+// 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class UnusedCaseEnumUnboxingTest extends EnumUnboxingTestBase {
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final EnumKeepRules enumKeepRules;
+
+ @Parameterized.Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public UnusedCaseEnumUnboxingTest(
+ TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ R8TestRunResult run =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(UnusedCaseEnumUnboxingTest.class)
+ .addKeepMainRule(Main.class)
+ .enableNeverClassInliningAnnotations()
+ .enableInliningAnnotations()
+ .addKeepRules(enumKeepRules.getKeepRules())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .allowDiagnosticInfoMessages()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::assertFieldsRemoved)
+ .inspectDiagnosticMessages(
+ m -> assertEnumIsUnboxed(MyEnum.class, Main.class.getSimpleName(), m))
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccess();
+ assertLines2By2Correct(run.getStdOut());
+ }
+
+ private void assertFieldsRemoved(CodeInspector codeInspector) {
+ codeInspector.clazz(Main.class);
+ }
+
+ @NeverClassInline
+ enum MyEnum {
+ USED1("used1"),
+ UNUSED1("unused1"),
+ USED2("used2"),
+ UNUSED2("unused2");
+
+ final String myField;
+
+ MyEnum(String data) {
+ this.myField = data;
+ }
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ printEnumField(MyEnum.USED1);
+ System.out.println("used1");
+ printEnumField(MyEnum.USED2);
+ System.out.println("used2");
+
+ printOrdinal(MyEnum.USED1);
+ System.out.println("0");
+ printOrdinal(MyEnum.USED2);
+ System.out.println("2");
+ }
+
+ @NeverInline
+ private static void printEnumField(MyEnum e) {
+ System.out.println(e.myField);
+ }
+
+ @NeverInline
+ private static void printOrdinal(MyEnum e) {
+ System.out.println(e.ordinal());
+ }
+ }
+}
