/*
* Copyright 2008 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.SourceInfo;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JBinaryOperation;
import com.google.gwt.dev.jjs.ast.JBinaryOperator;
import com.google.gwt.dev.jjs.ast.JDeclaredType;
import com.google.gwt.dev.jjs.ast.JExpression;
import com.google.gwt.dev.jjs.ast.JExpressionStatement;
import com.google.gwt.dev.jjs.ast.JField;
import com.google.gwt.dev.jjs.ast.JFieldRef;
import com.google.gwt.dev.jjs.ast.JLocal;
import com.google.gwt.dev.jjs.ast.JLocalRef;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JMethodBody;
import com.google.gwt.dev.jjs.ast.JMethodCall;
import com.google.gwt.dev.jjs.ast.JModVisitor;
import com.google.gwt.dev.jjs.ast.JNode;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JReferenceType;
import com.google.gwt.dev.jjs.ast.JReturnStatement;
import com.google.gwt.dev.jjs.ast.JStatement;
import com.google.gwt.dev.jjs.ast.JType;
import com.google.gwt.dev.jjs.ast.JVisitor;
import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
import com.google.gwt.dev.util.UnitTestTreeLogger;
import com.google.gwt.thirdparty.guava.common.base.Function;
import com.google.gwt.thirdparty.guava.common.base.Joiner;
import com.google.gwt.thirdparty.guava.common.base.Preconditions;
import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;
import javax.annotation.Nullable;
/**
* Test case for testing Jjs optimizers. Adds a convenient Result class.
*/
public abstract class OptimizerTestBase extends JJSTestBase {
protected boolean runDeadCodeElimination = false;
/**
* Holds the result of optimization to compare against expected results.
*/
protected final class Result {
private final String returnType;
private final String originalCode;
private final boolean madeChanges;
private final JProgram optimizedProgram;
private final String methodName;
public Result(JProgram optimizedProgram, String returnType,
String methodName, String originalCode, boolean madeChanges) {
this.optimizedProgram = optimizedProgram;
this.returnType = returnType;
this.methodName = methodName;
this.originalCode = originalCode;
this.madeChanges = madeChanges;
}
public void classHasMethods(String className, List<String> expectedMethodSnippets) {
final JDeclaredType targetClass = findClass(className);
Set<String> actualMethodSignatures = Sets.newHashSet();
for (JMethod method : targetClass.getMethods()) {
actualMethodSignatures.add(method.toString());
}
ImmutableSet<String> expectedMethodSignatures = FluentIterable.from(expectedMethodSnippets)
.transform(new Function<String, String>() {
@Nullable
@Override
public String apply(String unqualifiedMethodSignature) {
return targetClass.getName() + "." + unqualifiedMethodSignature;
}
}).toSet();
assertContainsAll(
expectedMethodSignatures, actualMethodSignatures);
}
/**
* Check whether the resulting is equivalent to {@code expected}.<p>
*
* Caveat: {@code expected} needs to be syntactically and type correct (as it will be compiled).
* Normalizer passes for the most part are not expected to produce type correct transformations
* as at the end the will be translated into an untyped language.
* In some cases the test might be able to use this function even if it is testing a pass
* that does not produce type correct program by replacing some standard mocked resources
* (tweaking method parameter and return types).
*/
public void into(String... expected) throws UnableToCompleteException {
// We can't compile expected code into non-main method.
Preconditions.checkState(methodName.equals(MAIN_METHOD_NAME));
JProgram program = compileSnippet(returnType, Joiner.on("\n").join(expected), true);
String expectedSource =
OptimizerTestBase.findMethod(program, methodName).getBody().toSource();
String actualSource =
OptimizerTestBase.findMethod(optimizedProgram, methodName)
.getBody().toSource();
assertEquals(originalCode, expectedSource, actualSource);
}
public void intoString(String... expected) {
String expectedSource = Joiner.on("\n").join(expected);
String actualSource =
OptimizerTestBase.findMethod(optimizedProgram, methodName)
.getBody().toSource();
// Trim surrounding {} and unindent body once
assertTrue(actualSource.startsWith("{"));
assertTrue(actualSource.endsWith("}"));
actualSource = actualSource.substring(1, actualSource.length() - 2).trim();
actualSource = Pattern.compile("^ ", Pattern.MULTILINE)
.matcher(actualSource).replaceAll("");
assertEquals(originalCode, expectedSource, actualSource);
}
public void noChange() {
assertFalse(madeChanges);
}
public JMethod findMethod(String methodName) {
return OptimizerTestBase.findMethod(optimizedProgram, methodName);
}
public JField findField(String fieldName) {
return OptimizerTestBase.findField(optimizedProgram,
"EntryPoint." + fieldName);
}
public JDeclaredType findClass(String className) {
return OptimizerTestBase.findDeclaredType(optimizedProgram, className);
}
public JProgram getOptimizedProgram() {
return optimizedProgram;
}
}
/**
* Asserts that there {@code method} calls all and only {@code expectedTargets}.
*/
protected static void assertCallsAndOnlyCalls(JMethod method, JMethod... expectedTargets) {
final Set<JMethod> actualTargets = Sets.newHashSet();
new JVisitor() {
@Override
public void endVisit(JMethodCall x, Context ctx) {
actualTargets.add(x.getTarget());
}
}.accept(method);
assertEquals(ImmutableSet.copyOf(expectedTargets), actualTargets);
}
/**
* Asserts that the compile fails with {@code expectedErrors}.
*/
public final void assertCompileFails(String code, String... expectedErrors) {
assert expectedErrors != null : "Failed compiles must specify error messages.";
UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
builder.setLowestLogLevel(TreeLogger.ERROR);
for (String expectedError : expectedErrors) {
builder.expectError(expectedError, null);
}
UnitTestTreeLogger errorLogger = builder.createLogger();
try {
optimize(errorLogger, "void", code);
fail("Compile should have failed but succeeded.");
} catch (Exception e) {
if (!(e.getCause() instanceof UnableToCompleteException)
&& !(e instanceof UnableToCompleteException)) {
e.printStackTrace();
fail();
}
}
errorLogger.assertCorrectLogEntries();
}
/**
* Asserts that the compile succeeds with {@code expectedWarnings}.
*/
public final Result assertCompileSucceeds(String code,
String... expectedWarnings) throws UnableToCompleteException {
UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
builder.setLowestLogLevel(TreeLogger.WARN);
if (expectedWarnings != null) {
for (String expectedWarning : expectedWarnings) {
builder.expectWarn(expectedWarning, null);
}
}
UnitTestTreeLogger errorLogger = builder.createLogger();
try {
return optimize(errorLogger, "void", code);
} catch (UnableToCompleteException e) {
fail("Compile failed");
} finally {
errorLogger.assertCorrectLogEntries();
}
return null;
}
/**
* Asserts that there {@code method} only calls {@code forwardsToMethod}.
*/
protected static void assertForwardsTo(JMethod method, JMethod forwardsToMethod) {
assertCallsAndOnlyCalls(method, forwardsToMethod);
}
protected static void assertOverrides(
Result result, String fullMethodSignature, String... overriddenMethodSignatures) {
assertEquals(ImmutableSet.copyOf(overriddenMethodSignatures),
findOverrides(result, fullMethodSignature));
}
protected static void assertParameterTypes(
final Result result, String methodName, String... parameterTypeNames) {
JMethod method = findMethod(result, methodName);
assertNotNull("Did not find method " + methodName, method);
assertEquals(parameterTypeNames.length, method.getParams().size());
JType[] parameterTypes = FluentIterable.from(Arrays.asList(parameterTypeNames))
.transform(new Function<String, JType>() {
@Nullable
@Override
public JType apply(String typeName) {
return findType(result, typeName);
}
})
.toArray(JType.class);
assertParameterTypes(method, parameterTypes);
}
protected static <T extends JNode> Collection<T> getNodes(
final Class<T> expressionClass, JNode inNode, final boolean exactClass) {
final List<T> result = Lists.newArrayList();
new JVisitor() {
@Override
public boolean visit(JNode x, Context ctx) {
if (x.getClass() == expressionClass || expressionClass.isInstance(x) && !exactClass) {
result.add(expressionClass.cast(x));
}
return true;
}
}.accept(inNode);
return result;
}
protected static void assertReturnType(
Result result, String methodName, String resultTypeName) {
JMethod method = findMethod(result, methodName);
assertNotNull("Did not find method " + methodName, method);
JDeclaredType resultType = result.findClass(resultTypeName);
assertNotNull("Did not find class " + resultTypeName, resultType);
assertEquals(resultType, method.getType().getUnderlyingType());
}
protected static JMethod findMethod(Result result, String methodName) {
int lastDot = methodName.lastIndexOf(".");
JMethod method = null;
if (lastDot != -1) {
String className = methodName.substring(0, lastDot);
JDeclaredType clazz = result.findClass(className);
assertNotNull("Did not find class " + className, clazz);
method = clazz.findMethod(methodName.substring(lastDot + 1), true);
} else {
method = result.findMethod(methodName);
}
return method;
}
protected static ImmutableSet<String> findOverrides(Result result, String fullMethodSignature) {
final Function<JMethod, String> METHOD_TO_STRING =
new Function<JMethod, String>() {
@Nullable
@Override
public String apply(JMethod method) {
return method.toString();
}
};
JMethod method = findMethod(result, fullMethodSignature);
assertNotNull("Method " + fullMethodSignature + " not found", method);
assertEquals(fullMethodSignature, method.toString());
return FluentIterable
.from(method.getOverriddenMethods())
.transform(METHOD_TO_STRING)
.toSet();
}
private static JReferenceType findType(Result result, String parameterTypeName) {
JReferenceType parameterType;
if (parameterTypeName.equals("null")) {
parameterType = JReferenceType.NULL_TYPE;
} else {
parameterType = result.findClass(parameterTypeName);
}
return parameterType;
}
/**
* Makes implicit <code>$clinit()</code> calls explicit to mimic the effect of other
* optimizations. Otherwise can not test optimizations that involve <code>$clinit</code> calls
* as they don't appear when compiling small snippets.
*
* @param method method to transform to make <code>$clinit</code> calls explicit.
*/
private void insertImplicitClinitCalls(final JMethod method) {
// Mimic the method inliner which inserts clinits calls prior to method or field dereference.
// The actual clinit() calls might be inserted as a result of optimizations: e,g,
// DeadCodeElimination inserts clinit calls when it removes (some) field accesses or method
// calls.
final JMethodBody body = (JMethodBody) method.getBody();
new JModVisitor() {
private JMethodCall createClinitCall(SourceInfo sourceInfo, JDeclaredType targetType) {
JMethod clinit = targetType.getClinitTarget().getClinitMethod();
assert (JProgram.isClinit(clinit));
return new JMethodCall(sourceInfo, null, clinit);
}
private JMultiExpression createMultiExpressionForInstanceAndClinit(JExpression x) {
JMultiExpression multi = new JMultiExpression(x.getSourceInfo());
JMethodCall clinit = null;
if (x instanceof JMethodCall) {
JExpression instance = ((JMethodCall) x).getInstance();
// Any instance expression goes first (this can happen even with statics).
if (instance != null) {
multi.addExpressions(instance);
JLocal var = JProgram.createLocal(instance.getSourceInfo(), "$t", instance.getType(),
false, body);
JLocalRef localRef = var.makeRef(var.getSourceInfo());
instance = new JBinaryOperation(instance.getSourceInfo(), localRef.getType(),
JBinaryOperator.ASG, localRef, instance);
}
clinit = createClinitCall(x.getSourceInfo(),
((JMethodCall) x).getTarget().getEnclosingType());
} else if (x instanceof JFieldRef) {
clinit = createClinitCall(x.getSourceInfo(), ((JFieldRef) x).getEnclosingType());
}
// If we need a clinit call, add it first
if (clinit != null) {
multi.addExpressions(clinit);
}
multi.addExpressions(x);
return multi;
}
@Override
public void endVisit(JMethodCall x, Context ctx) {
ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
}
@Override
public void endVisit(JFieldRef x, Context ctx) {
ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
}
}.accept(method);
}
protected final Result optimize(TreeLogger logger, final String returnType,
final String... codeSnippet) throws UnableToCompleteException {
return optimizeMethod(logger, MAIN_METHOD_NAME, returnType, codeSnippet);
}
protected final Result optimize(final String returnType,
final String... codeSnippet) {
UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
builder.setLowestLogLevel(TreeLogger.WARN);
try {
return optimize(null, returnType, codeSnippet);
} catch (UnableToCompleteException e) {
fail();
return null;
}
}
/**
* Test the effect of an optimization on a JMultiExpression.
* JMultiExpression can not be constructed from source code at the moment as it is not a valid
* java source construct.
*
* @param addClinitCalls whether to insert the implicit clinit calls. This is necessary because
* clinit() methods are synthetic can not be inserted explicitly as source
* code calls.
* @param returnType the return type of the JMultiExpression. Must be <code>void</code> or
* compatible with the last expression.
* @param expressionSnippets source code of the expressions.
* @return the optimization result.
* @throws UnableToCompleteException
*/
protected final Result optimizeExpressions(boolean addClinitCalls, final String returnType,
final String... expressionSnippets)
throws UnableToCompleteException {
// TODO(rluble): Not very elegant to require that the snippets be statements instead of
// expressions.
assert expressionSnippets.length > 0;
// Compile as statements
if (!returnType.equals("void")) {
expressionSnippets[expressionSnippets.length - 1] =
"return " + expressionSnippets[expressionSnippets.length - 1];
}
String snippet = Joiner.on(";\n").join(expressionSnippets) + ";\n";
final JProgram program = compileSnippet(returnType, snippet, true);
JMethod method = findMethod(program, MAIN_METHOD_NAME);
JMethodBody body = (JMethodBody) method.getBody();
JMultiExpression multi = new JMultiExpression(body.getSourceInfo());
// Transform statement sequence into a JMultiExpression
for (JStatement stmt : body.getStatements()) {
if (stmt instanceof JExpressionStatement) {
JExpressionStatement exprStmt = (JExpressionStatement) stmt;
JExpression expr = exprStmt.getExpr();
multi.addExpressions(expr);
} else if (stmt instanceof JReturnStatement) {
JReturnStatement returnStatement = (JReturnStatement) stmt;
JExpression expr = returnStatement.getExpr();
if (expr != null) {
multi.addExpressions(expr);
}
} else {
assert false : "Not a valid multiexpression";
}
}
// Take care of the return type
JStatement multiStm =
returnType.equals("void") ? multi.makeStatement() : multi.makeReturnStatement();
// Replace the method body
JMethodBody newBody = new JMethodBody(method.getBody().getSourceInfo());
newBody.getBlock().addStmt(multiStm);
method.setBody(newBody);
newBody.setMethod(method);
if (addClinitCalls) {
insertImplicitClinitCalls(method);
}
// Finally optimize.
boolean madeChanges = doOptimizeMethod(TreeLogger.NULL, program, method);
if (madeChanges && runDeadCodeElimination) {
DeadCodeElimination.exec(program);
}
return new Result(program, returnType, MAIN_METHOD_NAME, snippet, madeChanges);
}
protected final Result optimizeMethod(final String methodName,
final String mainMethodReturnType, final String... mainMethodSnippet)
throws UnableToCompleteException {
return optimizeMethod(null, methodName, mainMethodReturnType, mainMethodSnippet);
}
protected final Result optimizeMethod(TreeLogger logger, final String methodName,
final String mainMethodReturnType, final String... mainMethodSnippet)
throws UnableToCompleteException {
if (logger == null) {
logger = this.logger;
}
String snippet = Joiner.on("\n").join(mainMethodSnippet);
JProgram program = compileSnippet(logger, mainMethodReturnType, snippet, true);
JMethod method = findMethod(program, methodName);
boolean madeChanges = doOptimizeMethod(logger, program, method);
if (madeChanges && runDeadCodeElimination) {
DeadCodeElimination.exec(program);
}
return new Result(program, mainMethodReturnType, methodName, snippet, madeChanges);
}
protected abstract boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method)
throws UnableToCompleteException;
}