/*
* 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.dev.jjs.SourceInfo;
import com.google.gwt.dev.jjs.ast.JBinaryOperation;
import com.google.gwt.dev.jjs.ast.JBinaryOperator;
import com.google.gwt.dev.jjs.ast.JBlock;
import com.google.gwt.dev.jjs.ast.JBooleanLiteral;
import com.google.gwt.dev.jjs.ast.JCastOperation;
import com.google.gwt.dev.jjs.ast.JConditional;
import com.google.gwt.dev.jjs.ast.JExpression;
import com.google.gwt.dev.jjs.ast.JExpressionStatement;
import com.google.gwt.dev.jjs.ast.JIfStatement;
import com.google.gwt.dev.jjs.ast.JPrefixOperation;
import com.google.gwt.dev.jjs.ast.JPrimitiveType;
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.JUnaryOperator;
import com.google.gwt.dev.jjs.ast.JValueLiteral;
import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
import java.util.List;
/**
* Methods that both construct and try to simplify AST nodes. If simplification
* fails, then the methods will return an original, unmodified version of the
* node if one is supplied. The routines do not recurse into their arguments;
* the arguments are assumed to already be simplified as much as possible.
*/
public class Simplifier {
/**
* Negate the supplied expression if negating it makes the expression shorter.
* Otherwise, return null.
*/
private static JExpression maybeGetNegatedExpressionArgument(JExpression expression) {
if (expression instanceof JPrefixOperation) {
JPrefixOperation prefixOperation = (JPrefixOperation) expression;
if (prefixOperation.getOp() == JUnaryOperator.NOT
// Don't flip negations on floating point comparisons
&& !isFloatingPointComparison(prefixOperation.getArg())) {
return prefixOperation.getArg();
}
}
return null;
}
private static <T> List<T> allButLast(List<T> list) {
return list.subList(0, list.size() - 1);
}
private static <T> T last(List<T> list) {
return list.get(list.size() - 1);
}
/**
* This class provides only static methods. No instances will ever be created.
*/
private Simplifier() {
}
/**
* Simplify cast operations. Used when creating a cast in DeadCodeElimination. For simplifying
* casts that are actually in the AST, cast(JCastOperation) is used instead.
*
* <pre>
* (int) 1 -> 1
* (A) (a,b) -> (a, (A) b)
* </pre>
*
* @param type the Type to cast the expression <code>exp</code> to.
* @param exp the current JExpression under the cast as it is being simplified.
* @return the simplified expression.
*/
public static JExpression cast(JType type, JExpression exp) {
return simplifyCast(new JCastOperation(exp.getSourceInfo(), type, exp));
}
/**
* Simplify cast operations.
*
* <pre>
* (int) 1 -> 1
* (A) (a,b) -> (a, (A) b)
* </pre>
*
* @param castExpression a JCastOperation to be simplified.
* @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
*/
public static JExpression simplifyCast(JCastOperation castExpression) {
SourceInfo info = castExpression.getSourceInfo();
JType type = castExpression.getCastType();
JExpression argument = castExpression.getExpr();
if (type == argument.getType()) {
return argument;
}
if (argument instanceof JMultiExpression) {
// (T) (a, b, c) -> (a, b,(T) c)
JMultiExpression argumentAsMultiExpression = (JMultiExpression) argument;
JMultiExpression simplifiedExpression = new JMultiExpression(info);
simplifiedExpression.addExpressions(allButLast(argumentAsMultiExpression.getExpressions()));
simplifiedExpression.addExpressions(
simplifyCast(
new JCastOperation(info, type, last(argumentAsMultiExpression.getExpressions()))));
return simplifiedExpression;
}
if (type.isPrimitiveType() && (argument instanceof JValueLiteral)) {
// Statically evaluate casting literals.
JPrimitiveType primitiveType = (JPrimitiveType) type;
JValueLiteral valueLiteral = (JValueLiteral) argument;
JValueLiteral simplifiedExpression = primitiveType.coerce(valueLiteral);
if (simplifiedExpression != null) {
return simplifiedExpression;
}
}
/*
* Discard casts from byte or short to int, because such casts are always
* implicit anyway. Cannot coerce char since that would change the semantics
* of concat.
*/
if (type == JPrimitiveType.INT) {
if ((argument.getType() == JPrimitiveType.SHORT)
|| (argument.getType() == JPrimitiveType.BYTE)) {
return argument;
}
}
// no simplification made
return castExpression;
}
/**
* Simplify conditional expressions.
*
* <pre>
* (a,b,c)?d:e -> a,b,(c?d:e)
* true ? then : else -> then
* false ? then : else -> else
* cond ? true : else) -> cond || else
* cond ? false : else -> !cond && else
* cond ? then : true -> !cond || then
* cond ? then : false -> cond && then
* !cond ? then : else -> cond ? else : then
* </pre>
*
* @param expression a JCondintional to be simplified.
* @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
*/
public static JExpression simplifyConditional(JConditional expression) {
SourceInfo info = expression.getSourceInfo();
JType type = expression.getType();
JExpression conditionExpression = expression.getIfTest();
JExpression thenExpression = expression.getThenExpr();
JExpression elseExpression = expression.getElseExpr();
if (conditionExpression instanceof JMultiExpression) {
// (a,b,c)?d:e -> a,b,(c?d:e)
JMultiExpression conditionMultiExpression = (JMultiExpression) conditionExpression;
JMultiExpression simplifiedExpression = new JMultiExpression(info);
simplifiedExpression.addExpressions(allButLast(conditionMultiExpression.getExpressions()));
simplifiedExpression.addExpressions(
simplifyConditional(
new JConditional(info, type, last(conditionMultiExpression.getExpressions()),
thenExpression, elseExpression)));
return simplifiedExpression;
}
if (conditionExpression instanceof JBooleanLiteral) {
return ((JBooleanLiteral) conditionExpression).getValue()
// e.g. (true ? then : else) -> then
? thenExpression
// e.g. (false ? then : else) -> else
: elseExpression;
}
if (thenExpression instanceof JBooleanLiteral) {
return ((JBooleanLiteral) thenExpression).getValue()
// e.g. (cond ? true : else) -> cond || else
? or(info, conditionExpression, elseExpression)
// e.g. (cond ? false : else) -> !cond && else
: and(info,
negate(conditionExpression.getSourceInfo(), conditionExpression),
elseExpression);
}
if (elseExpression instanceof JBooleanLiteral) {
return ((JBooleanLiteral) elseExpression).getValue()
// e.g. (cond ? then : true) -> !cond || then
? or(info, negate(conditionExpression.getSourceInfo(), conditionExpression), thenExpression)
// e.g. (cond ? then : false) -> cond && then
: and(info, conditionExpression, thenExpression);
}
// e.g. (!cond ? then : else) -> (cond ? else : then)
JExpression negatedExpressionArgument = maybeGetNegatedExpressionArgument(conditionExpression);
if (negatedExpressionArgument != null) {
return simplifyConditional(
new JConditional(info, type, negatedExpressionArgument, elseExpression, thenExpression));
}
// Not simplified.
return expression;
}
/**
* Simplifies an if then else statement.
*
* <pre>
* if(a,b,c) d [else e] -> {a; b; if(c) d [else e]; }
* if(true) a [else b] -> a
* if(false) a else b -> b
* if(notImpl(c)) a else b -> if(c) b else a
* if(true) ; else b -> true
* if(false) a [else ;] -> false
* if(c) ; [else ;] -> c
*</pre>
*
* @param ifStatement the statement to simplify.
* @param methodReturnType the return type of the method where the statement resides if any
* @return the simplified statement if a simplification could be done and <code>ifStatement</code>
* otherwise.
*/
public static JStatement simplifyIfStatement(JIfStatement ifStatement, JType methodReturnType) {
SourceInfo info = ifStatement.getSourceInfo();
JExpression conditionExpression = ifStatement.getIfExpr();
JStatement thenStmt = ifStatement.getThenStmt();
JStatement elseStmt = ifStatement.getElseStmt();
if (conditionExpression instanceof JMultiExpression) {
// if(a,b,c) d else e -> {a; b; if(c) d else e; }
JMultiExpression condMulti = (JMultiExpression) conditionExpression;
JBlock simplifiedStatement = new JBlock(info);
for (JExpression expr : allButLast(condMulti.getExpressions())) {
simplifiedStatement.addStmt(expr.makeStatement());
}
simplifiedStatement.addStmt(
simplifyIfStatement(
new JIfStatement(info, last(condMulti.getExpressions()), thenStmt, elseStmt),
methodReturnType));
return simplifiedStatement;
}
if (conditionExpression instanceof JBooleanLiteral) {
boolean conditionValue = ((JBooleanLiteral) conditionExpression).getValue();
if (conditionValue && !JjsUtils.isEmptyBlock(thenStmt)) {
// If true, replace myself with then statement
return thenStmt;
} else if (!conditionValue && !JjsUtils.isEmptyBlock(elseStmt)) {
// If false, replace myself with else statement
return elseStmt;
} else {
// just prune me.
return conditionExpression.makeStatement();
}
}
if (JjsUtils.isEmptyBlock(thenStmt) && JjsUtils.isEmptyBlock(elseStmt)) {
return conditionExpression.makeStatement();
}
if (!JjsUtils.isEmptyBlock(elseStmt)) {
// if (!cond) foo else bar -> if (cond) bar else foo
JExpression negationArugment =
Simplifier.maybeGetNegatedExpressionArgument(conditionExpression);
if (negationArugment != null) {
// Force sub-parts to blocks, otherwise we break else-if chains.
// TODO: this goes away when we normalize the Java AST properly.
thenStmt = ensureBlock(thenStmt);
elseStmt = ensureBlock(elseStmt);
return simplifyIfStatement(
new JIfStatement(info, negationArugment, elseStmt, thenStmt), methodReturnType);
}
}
JStatement rewritenStatement =
rewriteIfStatementAsExpression(
info, conditionExpression, thenStmt, elseStmt, methodReturnType);
if (rewritenStatement != null) {
return rewritenStatement;
}
// no simplification made
return ifStatement;
}
/**
* Simplifies an negation expression.
*
* !(a > b) => a <= b
*
* @param expression the expression to simplify.
* @return the simplified expression if a simplification could be done and <code>expr</code>
* otherwise.
*/
public static JExpression simplifyNot(JPrefixOperation expression) {
JExpression argument = expression.getArg();
if (isFloatingPointComparison(argument)) {
// Don't negate floating point expression because it changes the values when NaNs are
// involved. E.g. !(Nan > 3) is not equivalent to (Nan <= 3).
return expression;
}
SourceInfo info = expression.getSourceInfo();
if (argument instanceof JMultiExpression) {
// !(a,b,c) -> (a,b,!c)
JMultiExpression multiExpression = (JMultiExpression) argument;
JMultiExpression simplifiedExpression = new JMultiExpression(info);
simplifiedExpression.addExpressions(allButLast(multiExpression.getExpressions()));
simplifiedExpression.addExpressions(negate(info, last(multiExpression.getExpressions())));
return simplifiedExpression;
}
if (argument instanceof JBinaryOperation) {
// try to invert the binary operator
JBinaryOperation binaryExpression = (JBinaryOperation) argument;
switch (binaryExpression.getOp()) {
case EQ:
// e.g. !(x == y) -> x != y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.NEQ,
binaryExpression.getLhs(), binaryExpression.getRhs());
case NEQ:
// e.g. !(x != y) -> x == y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.EQ,
binaryExpression.getLhs(), binaryExpression.getRhs());
case GT:
// e.g. !(x > y) -> x <= y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.LTE,
binaryExpression.getLhs(), binaryExpression.getRhs());
case LTE:
// e.g. !(x <= y) -> x > y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.GT,
binaryExpression.getLhs(), binaryExpression.getRhs());
case GTE:
// e.g. !(x >= y) -> x < y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.LT,
binaryExpression.getLhs(), binaryExpression.getRhs());
case LT:
// e.g. !(x < y) -> x >= y
return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.GTE,
binaryExpression.getLhs(), binaryExpression.getRhs());
}
}
if (argument instanceof JPrefixOperation) {
// try to invert the unary operator
JPrefixOperation prefixExpression = (JPrefixOperation) argument;
// e.g. !!x -> x
if (prefixExpression.getOp() == JUnaryOperator.NOT) {
return prefixExpression.getArg();
}
}
if (argument instanceof JBooleanLiteral) {
JBooleanLiteral booleanLiteral = (JBooleanLiteral) argument;
return JBooleanLiteral.get(!booleanLiteral.getValue());
}
// no simplification made.
return expression;
}
private static boolean isFloatingPointComparison(JExpression expr) {
if (expr instanceof JBinaryOperation) {
JBinaryOperation binaryOperation = (JBinaryOperation) expr;
return
binaryOperation.getType() == JPrimitiveType.BOOLEAN
&& (binaryOperation.getLhs().getType() == JPrimitiveType.FLOAT
|| binaryOperation.getLhs().getType() == JPrimitiveType.DOUBLE
|| binaryOperation.getRhs().getType() == JPrimitiveType.FLOAT
|| binaryOperation.getRhs().getType() == JPrimitiveType.DOUBLE);
}
return false;
}
private static JExpression negate(SourceInfo info, JExpression argument) {
return simplifyNot(new JPrefixOperation(info, JUnaryOperator.NOT, argument));
}
/**
* Simplify short circuit AND expressions.
*
* <pre>
* true && isWhatever() -> isWhatever()
* false && isWhatever() -> false
*
* isWhatever() && true -> isWhatever()
* isWhatever() && false -> false, unless side effects
*
* (a, b) && c -> (a, b && c)
* </pre>
*
* @param expression an AND JBinaryExpression to be simplified.
* @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
*
*/
public static JExpression simplifyAnd(JBinaryOperation expression) {
assert expression.getOp() == JBinaryOperator.AND
: "Simplifier.and was called with " + expression;
JExpression lhs = expression.getLhs();
JExpression rhs = expression.getRhs();
SourceInfo info = expression.getSourceInfo();
if (lhs instanceof JMultiExpression) {
// (a,b,c)&&d -> a,b,(c&&d)
JMultiExpression lhsMultiExpression = (JMultiExpression) lhs;
JMultiExpression simplifiedExpression = new JMultiExpression(info);
simplifiedExpression.addExpressions(allButLast(lhsMultiExpression.getExpressions()));
simplifiedExpression.addExpressions(
and(info, last(lhsMultiExpression.getExpressions()), rhs));
return simplifiedExpression;
}
if (lhs instanceof JBooleanLiteral) {
return (((JBooleanLiteral) lhs).getValue()) ? rhs : lhs;
}
if (rhs instanceof JBooleanLiteral) {
if (((JBooleanLiteral) rhs).getValue()) {
return lhs;
} else if (!lhs.hasSideEffects()) {
// Do not remove lhs if it had side effects
return rhs;
}
}
// no simplification made.
return expression;
}
private static JExpression and(SourceInfo info, JExpression lhs, JExpression rhs) {
return simplifyAnd(
new JBinaryOperation(info, JPrimitiveType.BOOLEAN, JBinaryOperator.AND, lhs, rhs));
}
/**
* Simplify short circuit OR expressions.
*
* <pre>
* true || isWhatever() -> true
* false || isWhatever() -> isWhatever()
*
* isWhatever() || false isWhatever()
* isWhatever() || true -> true, unless side effects
*
* (a, b) || c -> (a, b || c)
* </pre>
*
* @param expression an OR JBinaryExpression to be simplified.
* @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
*
*/
public static JExpression simplifyOr(JBinaryOperation expression) {
assert expression.getOp() == JBinaryOperator.OR
: "Simplifier.or was called with " + expression;
JExpression lhs = expression.getLhs();
JExpression rhs = expression.getRhs();
SourceInfo info = expression.getSourceInfo();
if (lhs instanceof JMultiExpression) {
// (a,b,c)|| d -> a,b,(c||d)
JMultiExpression lhsMultiExpression = (JMultiExpression) lhs;
JMultiExpression simplifiedExpression = new JMultiExpression(info);
simplifiedExpression.addExpressions(allButLast(lhsMultiExpression.getExpressions()));
simplifiedExpression.addExpressions(or(info, last(lhsMultiExpression.getExpressions()), rhs));
return simplifiedExpression;
}
if (lhs instanceof JBooleanLiteral) {
return ((JBooleanLiteral) lhs).getValue() ? lhs : rhs;
}
if (rhs instanceof JBooleanLiteral) {
if (!((JBooleanLiteral) rhs).getValue()) {
return lhs;
} else if (!lhs.hasSideEffects()) {
return rhs;
}
}
return expression;
}
private static JExpression or(SourceInfo info, JExpression lhs, JExpression rhs) {
return simplifyOr(
new JBinaryOperation(info, JPrimitiveType.BOOLEAN, JBinaryOperator.OR, lhs, rhs));
}
private static JStatement ensureBlock(JStatement statement) {
if (statement == null) {
return null;
}
if (statement instanceof JBlock) {
return statement;
}
return new JBlock(statement.getSourceInfo(), statement);
}
private static JExpression extractExpression(JStatement statement) {
if (statement instanceof JExpressionStatement) {
return ((JExpressionStatement) statement).getExpr();
}
return null;
}
private static JStatement extractSingleStatement(JStatement statement) {
if (statement instanceof JBlock) {
JBlock block = (JBlock) statement;
if (block.getStatements().size() == 1) {
return extractSingleStatement(block.getStatements().get(0));
}
}
return statement;
}
private static JStatement rewriteIfStatementAsExpression(SourceInfo sourceInfo,
JExpression conditionExpression, JStatement thenStmt, JStatement elseStmt,
JType methodReturnType) {
thenStmt = extractSingleStatement(thenStmt);
elseStmt = extractSingleStatement(elseStmt);
if (thenStmt instanceof JReturnStatement && elseStmt instanceof JReturnStatement
&& methodReturnType != null) {
// Special case
// if () { return ..; } else { return ..; } =>
// return ... ? ... : ...;
JExpression thenExpression = ((JReturnStatement) thenStmt).getExpr();
JExpression elseExpression = ((JReturnStatement) elseStmt).getExpr();
if (thenExpression == null || elseExpression == null) {
// empty returns are not supported.
return null;
}
return
new JConditional(
sourceInfo, methodReturnType, conditionExpression, thenExpression, elseExpression
).makeReturnStatement();
}
if (elseStmt != null) {
// if () { } else { } -> ... ? ... : ... ;
JExpression thenExpression = extractExpression(thenStmt);
JExpression elseExpression = extractExpression(elseStmt);
if (thenExpression != null && elseExpression != null) {
return
new JConditional(
sourceInfo, JPrimitiveType.VOID, conditionExpression, thenExpression, elseExpression
).makeStatement();
}
} else {
// if () { } -> ... && ...;
JExpression thenExpression = extractExpression(thenStmt);
if (thenExpression != null) {
JBinaryOperator binaryOperator = JBinaryOperator.AND;
JExpression negationArgument = maybeGetNegatedExpressionArgument(conditionExpression);
if (negationArgument != null) {
conditionExpression = negationArgument;
binaryOperator = JBinaryOperator.OR;
}
return
new JBinaryOperation(
sourceInfo, JPrimitiveType.VOID, binaryOperator, conditionExpression, thenExpression
).makeStatement();
}
}
return null;
}
}