/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.jjs.impl;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JDeclarationStatement;
import com.google.gwt.dev.jjs.ast.JFieldRef;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JValueLiteral;
import com.google.gwt.dev.jjs.ast.JVisitor;
import com.google.gwt.dev.jjs.impl.EnumOrdinalizer.Tracker;
/**
* A set of tests for the conditions under which ordinalization is and is not allowed. The
* ordinalization is performed when allowed.
* <p>
* A complete test of the resulting ordinalization is not performed. However, the
* ImplementCastsAndTypeChecks and the EqualityNormalizer are run after the EnumOrdinalizer, to help
* ensure the integrity of the AST, such that there are no partially mismatched type assignments or
* comparisons, and that no binary operations between a primitive type and null have been added.
* Typically, such errors introduced by the EnumOrdinalizer are caught by these normalizers, so it
* makes sense to test the output in this way. Thus, we provide confidence that the AST is left in
* a coherent state, but it is not a complete test that ordinalization has completed correctly in
* every respec.
* <p>
* NOTE: the tests in this test case are very fragile. On one hand EnumOrdinalizer requires other
* passes to perform their cleanups to be effective; on the other some passes (DeadCodeElimination)
* optimize enums in a way that the tests might become ineffective and some artificial constructs
* are used to avoid this scenario. See {@link EnumOrdinalizerTest#setupNotInlineable()}.
*/
public class EnumOrdinalizerTest extends OptimizerTestBase {
/*
* Always run ImplementCastsAndTypeChecks and EqualityNormalizer, even in cases where we
* are testing that ordinalization cannot occur, since there may be other
* enums (such as DummyEnum) which do get ordinalized, and we want to test
* that all is well regardless.
*/
private final boolean performCastReplacement = true;
private final boolean runEqualityNormalizer = true;
// These are enabled as needed for a given test
private boolean runMakeCallsStatic;
private boolean runMethodInliner;
private boolean runMethodCallTightener;
private boolean runPruner;
private boolean runTypeTightener;
@Override
protected void setUp() throws Exception {
super.setUp();
EnumOrdinalizer.enableTracker();
EnumOrdinalizer.resetTracker();
// defaults, can be overridden by individual test cases
runTypeTightener = false;
runMethodCallTightener = false;
runMethodInliner = true;
runMakeCallsStatic = true;
// Opportunities for ordinalization are only present after unused references to $VALUES are
// pruned.
// NOTE: because we are pruning, each test case needs to make sure that enums that are
// considered for ordinalization are still live.
runPruner = true;
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
public void testOrdinalizeBasicAssignment()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit apple = Fruit.APPLE;",
"Fruit orange = Fruit.ORANGE;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeNewArrayAndAssignmentLocalRef()
throws UnableToCompleteException {
setupFruitEnum();
Result result =
optimize("void", "Fruit[] fruits = new Fruit[] {Fruit.APPLE, Fruit.ORANGE, Fruit.APPLE};",
"if (fruits[0] == Fruit.APPLE) {",
" fruits[0] = Fruit.ORANGE;",
"}");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeNewArrayOfArrayAndAssignmentLocalRef()
throws UnableToCompleteException {
setupFruitEnum();
Result result =
optimize("void", "Fruit[][] fruits = new Fruit[][] ",
" {{Fruit.APPLE, Fruit.ORANGE},{Fruit.APPLE, Fruit.ORANGE}};",
"if (fruits[0][1] == Fruit.APPLE) {",
" fruits[0][1] = Fruit.ORANGE;",
"}");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeNewArrayAndAssignmentFieldRef()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("private final Fruit[] fruits = new Fruit[] ",
" {Fruit.APPLE, Fruit.ORANGE, Fruit.APPLE};");
Result result = optimize("void", "EntryPoint ep = new EntryPoint();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableFinalFieldUninitializedByDefault()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("private final Fruit uninitializedFinalFruit;",
"public EntryPoint() {",
" uninitializedFinalFruit = Fruit.ORANGE;",
"}");
Result result = optimize("void", "EntryPoint ep = new EntryPoint();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeSwitchStatement()
throws UnableToCompleteException {
setupFruitEnum();
setupFruitSwitchMethod();
Result result = optimize("void", "String apple = fruitSwitch(Fruit.APPLE);",
"String orange = fruitSwitch(Fruit.ORANGE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeIfStatement()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl(
"public static String fruitIf(Fruit fruit) {",
" if (fruit == Fruit.APPLE) {",
" return \"Apple\";",
" } else if (fruit == Fruit.ORANGE) {",
" return \"Orange\";",
" } else {",
" return \"Unknown\";",
" }",
"}");
Result result = optimize("void", "String apple = fruitIf(Fruit.APPLE);",
"String orange = fruitIf(Fruit.ORANGE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeConditional()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void",
"Fruit fruit = (new Integer(1)).toString().isEmpty() ? Fruit.APPLE : Fruit.ORANGE;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeFieldRefOrdinalMethodCall()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "int i = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeVariableRefOrdinalMethodCall()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"int i = fruit.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeUnusedEmptyEnum() throws UnableToCompleteException {
setupEmptyEnum();
Result result = optimize("void", "EmptyEnum myEnum;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$EmptyEnum") ||
!tracker.isVisited("test.EntryPoint$EmptyEnum"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeUnusedEnum() throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit myEnum;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit") ||
!tracker.isVisited("test.EntryPoint$Fruit"));
// This enum is not referenced and it has gone away before ordinalizing, however make
// sure there are no references anyway.
tracker.addOrdinalized("test.EntryPoint$Fruit");
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizeMethodCallExpressionOrdinalFieldRef()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static Fruit getResolvedFruit(Fruit fruit) {",
" if (fruit == Fruit.APPLE) {",
" return Fruit.ORANGE;",
" } else { ",
" return Fruit.APPLE;",
" }",
"}");
addSnippetClassDecl("public static int switchMethodCall(Fruit fruit) {",
" int retVal = 0;",
" switch (getResolvedFruit(fruit)) {",
" case APPLE: retVal = 12; break;",
" case ORANGE:retVal = 73; break;",
" }",
" return retVal;",
"}");
Result result = optimize("void", "int i = switchMethodCall(Fruit.APPLE);",
"Fruit fruit = Fruit.ORANGE;",
"int j = switchMethodCall(fruit);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableStaticFieldRef()
throws UnableToCompleteException {
// this will cause a static field ref in the enum clinit
setupFruitEnumWithStaticField();
Result result = optimize("void",
"String y = Fruit.staticField + Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableStaticMethod()
throws UnableToCompleteException {
// this will cause a static method enum class
setupFruitEnumWithStaticMethod();
Result result = optimize("void", "int y = Fruit.staticMethod() + Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableCallingValues()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "int l = Fruit.values().length;",
"int ord = Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableStaticFieldRefToVALUES()
throws UnableToCompleteException {
// this ends up inlining the values() method call, and thus $VALUES is referenced external
// to the Fruit enum class.
setupFruitEnum();
Result result = optimize("void", "Fruit[] fruits = Fruit.values();",
"int ord = Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testOrdinalizableStaticMethodThatRefsValuesLength()
throws UnableToCompleteException {
// this will cause a static method that references values().length
setupFruitEnumWithStaticMethodThatRefsValuesLength();
Result result = optimize("void", "Fruit y = Fruit.forInteger(0);",
"int ord = Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertTrue(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableInstanceStaticFieldRef()
throws UnableToCompleteException {
// this will cause a static field ref in the enum clinit
setupFruitEnumWithStaticField();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"String y = fruit.staticField;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableInstanceStaticMethod()
throws UnableToCompleteException {
// this will cause a static method enum class
setupFruitEnumWithStaticMethod();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"int y = fruit.staticMethod();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableClassLiteralReference()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Class clazz = Fruit.class;",
"String clazzStr = clazz.toString() + Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableEnumValueOfWithClassLiteralArg()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Object Carrot = Enum.valueOf(Fruit.class, \"APPLE\");",
"String carrot = Carrot.toString() + Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableGetClassMethodCall()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Class clazz = Fruit.APPLE.getClass();",
"String clazzStr = clazz.toString() + Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastToEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Object obj = new Object();",
"Fruit fruit = (Fruit) obj;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastToArrayOfEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Enum[] enumArray = new Enum[10];",
"Fruit[] fruitArray = (Fruit[]) enumArray;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastFromArrayOfEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit[] fruitArray = new Fruit[10];",
"Enum[] enumArray = (Enum[]) fruitArray;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastToArrayOfArrayOfEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Enum[][] enumArray = new Enum[10][10];",
"Fruit[][] fruitArray = (Fruit[][]) enumArray;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastFromArrayOfArrayOfEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit[][] fruitArray = new Fruit[10][10];",
"Enum[][] enumArray = (Enum[][]) fruitArray;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableExplicitCastFromEnumClass()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Enum Carrot = (Enum) Fruit.APPLE;",
"String carrot = Carrot.toString();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableOrdinalMethodRefFromExplicitCastWithBlackListableSubExpression()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "int ord = " +
"((Fruit) Enum.valueOf(Fruit.class,\"APPLE\")).ordinal();",
"int ord2 = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableInstanceFieldRef()
throws UnableToCompleteException {
// this will cause an instance field ref in the enum constructor
setupFruitEnumWithInstanceField();
Result result = optimize("void", "String instanceField = Fruit.APPLE.instanceField;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableInstanceOfEnumExpression()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"if (fruit instanceof Enum) {",
" fruit = Fruit.ORANGE;",
"}");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableInstanceOfEnumTestType()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Object fruitObj = new Object();",
"if (fruitObj instanceof Fruit) {",
" fruitObj = null;",
"}",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableStaticMethodCallValues()
throws UnableToCompleteException {
// make sure values() method call doesn't doesn't get inlined
runMethodInliner = false;
setupFruitEnum();
Result result = optimize("void", "Fruit[] fruits = Fruit.values();",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableJsniFieldRef()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static Fruit instanceFruit;");
addSnippetClassDecl("public static native void jsniMethod() /*-{",
" var x = @test.EntryPoint::instanceFruit",
"}-*/");
Result result = optimize("void", "instanceFruit = Fruit.APPLE;",
"jsniMethod();",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableJsniFieldRefStatic()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static native void jsniMethod() /*-{",
" var x = @test.EntryPoint.Fruit::APPLE",
"}-*/");
Result result = optimize("void", "jsniMethod();",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableJsniFieldRefClassLiteral()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static native void jsniMethod() /*-{",
" var x = @test.EntryPoint.Fruit::class",
"}-*/");
Result result = optimize("void", "jsniMethod();",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpAssignment()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void",
"Enum tomato;",
"tomato = Fruit.APPLE;",
"int ord = tomato.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastFieldInitializedWithNullByDefault()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("static private Fruit uninitializedFruitAsNull;");
Result result = optimize("void", "if (uninitializedFruitAsNull != Fruit.APPLE) {",
" uninitializedFruitAsNull = Fruit.ORANGE;",
"}",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpEquals()
throws UnableToCompleteException {
setupFruitAndVegetableEnums();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"Enum carrot = (Enum) Vegetable.CARROT;",
"boolean test = (fruit == carrot);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertTrue(tracker.isVisited("test.EntryPoint$Vegetable"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Vegetable"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpNotEquals()
throws UnableToCompleteException {
setupFruitAndVegetableEnums();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"Enum carrot = (Enum) Vegetable.CARROT;",
// do in opposite order from OpEquals test
"boolean test = (carrot != fruit);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertTrue(tracker.isVisited("test.EntryPoint$Vegetable"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Vegetable"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpEqualsNull()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static boolean testIsNull(Fruit fruit) {",
" if (fruit == null) {",
" return true;",
" } else {",
" return false;",
" }",
"}");
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"boolean isNull = testIsNull(fruit) || testIsNull(Fruit.ORANGE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpNotEqualsNull()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static boolean testIsNull(Fruit fruit) {",
" if (fruit != null) {",
" return true;",
" } else {",
" return false;",
" }",
"}");
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"boolean isNull = testIsNull(fruit) || testIsNull(Fruit.ORANGE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpStringConcat()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"String str = \"A string followed by \" + fruit;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpStringConcat2()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"String str = fruit + \" followed by a string\";");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastBinaryOpStringConcatAssignment()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = Fruit.APPLE;",
"String str = \"A string concatenated with: \";",
"str += fruit;");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastDeclarationToNull()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit = null;",
"int ord = fruit == null ? Util.notInlineable(Fruit.APPLE).ordinal() : fruit.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastAssignmentToNull()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Fruit fruit;",
"fruit = null;",
"int ord = fruit == null ? Util.notInlineable(Fruit.APPLE).ordinal() : fruit.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastDeclaration()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Enum tomato = Fruit.APPLE;",
"int ord = Fruit.APPLE.ordinal() + tomato.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastConditional()
throws UnableToCompleteException {
setupFruitAndVegetableEnums();
Result result = optimize("void", "Enum tomato = null;",
"tomato = (true) ? Fruit.APPLE : Vegetable.CARROT;",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal() +",
" Util.notInlineable(Vegetable.CARROT).ordinal() + tomato.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertTrue(tracker.isVisited("test.EntryPoint$Vegetable"));
assertTrue(tracker.isOrdinalized("test.EntryPoint$Vegetable"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastOverriddenMethodReturnType()
throws UnableToCompleteException {
// this test depends on the tighteners running
runTypeTightener = true;
runMethodCallTightener = true;
/*
* Create methods with covariant return type, which the MethodTypeTightener
* will optimize to no longer be covariant, so make sure we check original
* overridden method type.
*/
addSnippetClassDecl("public interface EnumInterface {",
" String name();",
"}");
addSnippetClassDecl("public abstract class AbstractClass<T extends EnumInterface> {",
" public abstract T getEnumClass();",
"}");
addSnippetClassDecl("public class CustomClass1 extends AbstractClass<EnumClass1> {",
" public EnumClass1 getEnumClass() { return EnumClass1.CONST1; }",
"}");
addSnippetClassDecl("public class CustomClass2 extends AbstractClass<EnumClass2> {",
" public EnumClass2 getEnumClass() { return EnumClass2.CONST2; }",
"}");
addSnippetClassDecl("public enum EnumClass1 implements EnumInterface {",
" CONST1;",
"}");
addSnippetClassDecl("public enum EnumClass2 implements EnumInterface {",
" CONST2;",
"}");
addSnippetClassDecl("public static void testEnumClass(AbstractClass abstractClass) {",
" EnumInterface enumClass = abstractClass.getEnumClass();",
"}");
Result result = optimize("void", "EntryPoint ep = new EntryPoint();",
"AbstractClass abstractClass1 = ep.new CustomClass1();",
"AbstractClass abstractClass2 = ep.new CustomClass2();",
"testEnumClass(abstractClass1);",
"testEnumClass(abstractClass2);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$EnumClass1"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$EnumClass1"));
assertTrue(tracker.isVisited("test.EntryPoint$EnumClass2"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$EnumClass2"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastMethodCallArgs()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static String getEnumString(Enum myEnum) {",
// make sure this method does something so not inlined
" int ord = myEnum.ordinal();",
" String retString = \"\";",
" for (int i = 0;i<ord;i++) {",
" retString += \"-\";",
" }",
" retString += myEnum.name();",
" return retString;",
"}");
Result result = optimize("void", "String stringApple = getEnumString(Fruit.APPLE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastMethodCallArgsNewArray()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static String getEnumString(Enum[] myEnumArray) {",
" String retString = \"\";",
" for (Enum myEnum : myEnumArray) {",
" retString += myEnum.name();",
" }",
" return retString;",
"}");
Result result = optimize("void",
"String stringFruits = getEnumString(new Enum[] {Fruit.APPLE, Fruit.ORANGE});");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastMethodCallVarArgs()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static String getEnumString(Enum...myEnumArray) {",
" String retString = \"\";",
" for (Enum myEnum : myEnumArray) {",
" retString += myEnum.name();",
" }",
" return retString;",
"}");
Result result = optimize("void",
"String stringFruits = getEnumString(Fruit.APPLE, Fruit.ORANGE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastNewArrayElements()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void", "Enum[] enums = new Enum[] {Fruit.APPLE, Fruit.ORANGE};");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastNewArrayArrayElements()
throws UnableToCompleteException {
setupFruitEnum();
Result result = optimize("void",
"Enum[][] enums = new Enum[][] {{Fruit.APPLE, Fruit.ORANGE},{Fruit.ORANGE, Fruit.APPLE}};");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableJsniMethodBodyParams()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static native void passEnumToJsniMethod(Enum myEnum) /*-{",
" myEnum == null; }-*/");
Result result = optimize("void", "passEnumToJsniMethod(Fruit.APPLE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastJsniMethodBodyParams()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static native void passEnumToJsniMethod(Fruit myEnum) /*-{",
" myEnum == null; }-*/;");
Result result = optimize("void", "passEnumToJsniMethod(Fruit.APPLE);");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableJsniMethodBodyCall()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static native void consumeFruitViaJsni() /*-{",
" var myJso = @test.EntryPoint::calledFromJsni(*)();",
"}-*/;",
"public static Fruit calledFromJsni() {",
" return Fruit.APPLE;",
"}");
Result result = optimize("void", "consumeFruitViaJsni();",
"int ord = Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastJsniMethodRefParams()
throws UnableToCompleteException {
setupFruitEnum();
setupFruitSwitchMethod();
addSnippetClassDecl("public static native void fruitSwitchViaJsni() /*-{",
" var myJso;",
" var result = @test.EntryPoint::fruitSwitch(Ltest/EntryPoint$Fruit;)(myJso);",
"}-*/");
Result result = optimize("void", "fruitSwitchViaJsni();",
"int ord = Util.notInlineable(Fruit.APPLE).ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastJsniMethodRefReturnType()
throws UnableToCompleteException {
setupFruitEnum();
addSnippetClassDecl("public static Fruit returnSomeFruit() {",
" return Fruit.APPLE;",
"}");
addSnippetClassDecl("public static native void jsniMethodRefWithEnumReturn() /*-{",
" var result = @test.EntryPoint::returnSomeFruit()();",
"}-*/");
Result result = optimize("void", "jsniMethodRefWithEnumReturn();",
"int ord = Fruit.APPLE.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
public void testNotOrdinalizableImplicitUpcastReturnStatement()
throws UnableToCompleteException {
setupFruitAndVegetableEnums();
addSnippetClassDecl("public static Enum returnAsEnum(int mode) {",
" if (mode == 0) {",
" return Fruit.APPLE;",
" } else {",
" return Vegetable.CARROT;",
" }",
"}");
Result result = optimize("void", "Enum myEnum = returnAsEnum(0);",
// do a second one, to prevent inlining
"Enum myOtherEnum = returnAsEnum(1);",
"int ord = myEnum.ordinal() + myOtherEnum.ordinal();");
EnumOrdinalizer.Tracker tracker = EnumOrdinalizer.getTracker();
assertTrue(tracker.isVisited("test.EntryPoint$Fruit"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Fruit"));
assertTrue(tracker.isVisited("test.EntryPoint$Vegetable"));
assertFalse(tracker.isOrdinalized("test.EntryPoint$Vegetable"));
assertAllEnumOrdinalizedReferencesReplaced(result.getOptimizedProgram(), tracker);
}
private void setupEmptyEnum() {
addSnippetClassDecl("public enum EmptyEnum {}");
}
private void setupFruitEnum() {
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE}");
setupNotInlineable("Fruit");
}
private void setupFruitEnumWithInstanceField() {
addSnippetClassDecl("public enum Fruit {APPLE(\"a\"), ORANGE(\"b\");",
" public final String instanceField;",
" private Fruit(String str) {",
" instanceField = str;",
" }",
"}");
setupNotInlineable("Fruit");
}
private void setupFruitEnumWithStaticField() {
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE;",
" public static String staticField = \"STATIC\";",
"}");
setupNotInlineable("Fruit");
}
private void setupFruitEnumWithStaticMethod() {
addSnippetImport("javaemul.internal.annotations.DoNotInline");
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE;",
" @DoNotInline",
" public static final int staticMethod() {",
" int x = 0;",
" return x;",
" }",
"}");
setupNotInlineable("Fruit");
}
private void setupFruitEnumWithStaticMethodThatRefsValuesArray() {
// add a little extra logic here, to prevent inlining
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE;",
" public static Fruit forInteger(int value) {",
" if (value < 0 || value >= 2) {",
" return ORANGE;",
" }",
" return Fruit.values()[value];",
" }",
"}");
}
private void setupFruitEnumWithStaticMethodThatRefsValuesLength() {
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE;",
" public static Fruit forInteger(int value) {",
" if (value < 0 || value >= Fruit.values().length) {",
" return ORANGE;",
" }",
" return APPLE;",
" }",
"}");
setupNotInlineable("Fruit");
}
private void setupVegetableEnum() {
addSnippetClassDecl("public enum Vegetable {CARROT, SPINACH}");
setupNotInlineable("Vegetable");
}
private void setupFruitAndVegetableEnums() {
addSnippetClassDecl("public enum Fruit {APPLE, ORANGE}");
addSnippetClassDecl("public enum Vegetable {CARROT, SPINACH}");
setupNotInlineable("Fruit", "Vegetable");
}
private void setupFruitSwitchMethod() {
addSnippetClassDecl("public static String fruitSwitch(Fruit fruit) {",
" switch(fruit) {",
" case APPLE: return \"Apple\";",
" case ORANGE: return \"Orange\";",
" default: return \"Unknown\";",
" }",
"}");
}
private void setupNotInlineable(String... classes) {
addSnippetClassDecl("public static class Util {");
for (String clazz : classes) {
addSnippetClassDecl(
" public static " + clazz + " notInlineable(" + clazz + " obj) {",
" if (new Integer(1).toString().isEmpty()) return obj;",
" return obj;",
" }");
}
addSnippetClassDecl("}");
}
@Override
protected boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method) {
/*
* EnumOrdinalizer depends MakeCallsStatic and MethodInliner running before
* it runs, since they cleanup the internal structure of an enum class to
* inline instance methods like $init.
*
* TypeTightener and methodCallTightener are necessary to test some cases
* involving implicit casts on overridden method call return types.
*
* These are a subset of the actual optimizers run in JJS.optimizeLoop().
*/
boolean didChange = false;
program.addEntryMethod(findMainMethod(program));
OptimizerContext optimizerContext = new FullOptimizerContext(program);
if (runMakeCallsStatic) {
didChange = MakeCallsStatic.exec(program, false, optimizerContext).didChange() || didChange;
}
if (runTypeTightener) {
didChange = TypeTightener.exec(program, optimizerContext).didChange() || didChange;
}
if (runMethodCallTightener) {
didChange = MethodCallTightener.exec(program, optimizerContext).didChange() || didChange;
}
if (runMethodInliner) {
didChange = MethodInliner.exec(program, optimizerContext).didChange() || didChange;
}
if (runPruner) {
didChange = Pruner.exec(program, true, optimizerContext).didChange() || didChange;
}
didChange = EnumOrdinalizer.exec(program, optimizerContext).didChange() || didChange;
/*
* Run these normalizers to sanity check the AST. If there are any
* dangling type substitutions, the ImplementCastsAndTypeChecks will generally find it.
* If there are any introduced binary ops between an int and a null, the
* EqualityNormalizer will find it.
*/
if (performCastReplacement) {
ComputeCastabilityInformation.exec(program, false);
ImplementCastsAndTypeChecks.exec(program, false);
}
if (runEqualityNormalizer) {
EqualityNormalizer.exec(program);
}
return didChange;
}
private void assertAllEnumOrdinalizedReferencesReplaced(JProgram program, final Tracker tracker) {
new JVisitor() {
@Override
public void endVisit(JFieldRef x, Context ctx) {
assertTrue(x.getField() + " was not replaced everywhere",
ctx.isLvalue() || !tracker.isOrdinalized(x.getEnclosingType().getName()));
}
@Override
public void endVisit(JDeclarationStatement x, Context ctx) {
assertTrue(x.getVariableRef().getTarget() + " was not replaced everywhere",
x.getInitializer() instanceof JValueLiteral ||
!(x.getVariableRef() instanceof JFieldRef) ||
!tracker.isOrdinalized(
((JFieldRef) x.getVariableRef()).getField().getEnclosingType().getName()));
}
}.accept(program);
}
}