public static boolean isAssociativeOperation(PsiPolyadicExpression expression) {
final IElementType tokenType = expression.getOperationTokenType();
final PsiType type = expression.getType();
final PsiPrimitiveType primitiveType;
if (type instanceof PsiClassType) {
primitiveType = PsiPrimitiveType.getUnboxedType(type);
if (primitiveType == null) {
return false;
}
} else if (type instanceof PsiPrimitiveType) {
primitiveType = (PsiPrimitiveType) type;
} else {
return false;
}
if (JavaTokenType.PLUS == tokenType || JavaTokenType.ASTERISK == tokenType) {
return !PsiType.FLOAT.equals(primitiveType) && !PsiType.DOUBLE.equals(primitiveType);
} else if (JavaTokenType.EQEQ == tokenType || JavaTokenType.NE == tokenType) {
return PsiType.BOOLEAN.equals(primitiveType);
} else if (JavaTokenType.AND == tokenType
|| JavaTokenType.OR == tokenType
|| JavaTokenType.XOR == tokenType) {
return true;
} else if (JavaTokenType.OROR == tokenType || JavaTokenType.ANDAND == tokenType) {
return true;
}
return false;
}
private static boolean polyadicExpressionsAreEquivalent(
@NotNull PsiPolyadicExpression polyadicExpression1,
@NotNull PsiPolyadicExpression polyadicExpression2) {
final IElementType tokenType1 = polyadicExpression1.getOperationTokenType();
final IElementType tokenType2 = polyadicExpression2.getOperationTokenType();
if (!tokenType1.equals(tokenType2)) {
return false;
}
final PsiExpression[] operands1 = polyadicExpression1.getOperands();
final PsiExpression[] operands2 = polyadicExpression2.getOperands();
if (operands1.length != operands2.length) {
return false;
}
for (int i = 0, length = operands1.length; i < length; i++) {
if (!expressionsAreEquivalent(operands1[i], operands2[i])) {
return false;
}
}
return true;
}
public static boolean areParenthesesNeeded(PsiJavaToken sign, PsiExpression rhs) {
if (rhs instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression) rhs;
final int precedence1 = getPrecedenceForOperator(binaryExpression.getOperationTokenType());
final IElementType signTokenType = sign.getTokenType();
final IElementType newOperatorToken = tokenMap.get(signTokenType);
final int precedence2 = getPrecedenceForOperator(newOperatorToken);
return precedence1 >= precedence2 || !isCommutativeOperator(newOperatorToken);
} else {
return rhs instanceof PsiConditionalExpression;
}
}
@Nullable
private String evaluate(PsiExpression expression, Map<String, Computable<String>> arguments) {
if (expression instanceof PsiPolyadicExpression) {
PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression) expression;
if (binaryExpression.getOperationTokenType() == JavaTokenType.PLUS) {
String r = "";
for (PsiExpression op : binaryExpression.getOperands()) {
String lhs = evaluate(op, arguments);
if (lhs == null) return null;
r += lhs;
}
return r;
}
} else if (expression instanceof PsiLiteralExpression) {
final Object value = ((PsiLiteralExpression) expression).getValue();
if (value instanceof String) {
return (String) value;
}
} else if (expression instanceof PsiReferenceExpression) {
final PsiElement result = ((PsiReferenceExpression) expression).resolve();
if (result instanceof PsiParameter) {
final String name = ((PsiParameter) result).getName();
final Computable<String> arg = arguments.get(name);
return arg == null ? null : arg.compute();
}
if (result instanceof PsiVariable) {
final PsiExpression initializer = ((PsiVariable) result).getInitializer();
if (initializer != null) {
return evaluate(initializer, arguments);
}
}
} else if (expression instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCall = (PsiMethodCallExpression) expression;
final String callText = methodCall.getMethodExpression().getText();
if (callText.equals("getTestName")) {
final PsiExpression[] psiExpressions = methodCall.getArgumentList().getExpressions();
if (psiExpressions.length == 1) {
if ("true".equals(psiExpressions[0].getText()) && !StringUtil.isEmpty(myTestName)) {
return UsefulTestCase.lowercaseFirstLetter(myTestName, true);
}
return myTestName;
}
}
}
if (expression != null) {
myLogMessages.add("Failed to evaluate " + expression.getText());
}
return null;
}
public static int getPrecedence(PsiExpression expression) {
if (expression instanceof PsiThisExpression
|| expression instanceof PsiLiteralExpression
|| expression instanceof PsiSuperExpression
|| expression instanceof PsiClassObjectAccessExpression
|| expression instanceof PsiArrayAccessExpression
|| expression instanceof PsiArrayInitializerExpression) {
return LITERAL_PRECEDENCE;
}
if (expression instanceof PsiReferenceExpression) {
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) expression;
if (referenceExpression.getQualifier() != null) {
return METHOD_CALL_PRECEDENCE;
} else {
return LITERAL_PRECEDENCE;
}
}
if (expression instanceof PsiMethodCallExpression || expression instanceof PsiNewExpression) {
return METHOD_CALL_PRECEDENCE;
}
if (expression instanceof PsiTypeCastExpression) {
return TYPE_CAST_PRECEDENCE;
}
if (expression instanceof PsiPrefixExpression) {
return PREFIX_PRECEDENCE;
}
if (expression instanceof PsiPostfixExpression) {
return POSTFIX_PRECEDENCE;
}
if (expression instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) expression;
return getPrecedenceForOperator(polyadicExpression.getOperationTokenType());
}
if (expression instanceof PsiInstanceOfExpression) {
return RELATIONAL_PRECEDENCE;
}
if (expression instanceof PsiConditionalExpression) {
return CONDITIONAL_PRECEDENCE;
}
if (expression instanceof PsiAssignmentExpression) {
return ASSIGNMENT_PRECEDENCE;
}
if (expression instanceof PsiParenthesizedExpression) {
return PARENTHESIZED_PRECEDENCE;
}
return -1;
}
@Nullable
private static PsiReferenceExpression getReferenceFromInstanceofExpression(
PsiExpression expression) {
if (expression instanceof PsiParenthesizedExpression) {
final PsiParenthesizedExpression parenthesizedExpression =
(PsiParenthesizedExpression) expression;
return getReferenceFromInstanceofExpression(parenthesizedExpression.getExpression());
} else if (expression instanceof PsiInstanceOfExpression) {
final PsiInstanceOfExpression instanceOfExpression = (PsiInstanceOfExpression) expression;
final PsiExpression operand =
ParenthesesUtils.stripParentheses(instanceOfExpression.getOperand());
if (!(operand instanceof PsiReferenceExpression)) {
return null;
}
return (PsiReferenceExpression) operand;
} else if (expression instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) expression;
final IElementType tokenType = polyadicExpression.getOperationTokenType();
if (JavaTokenType.OROR != tokenType) {
return null;
}
final PsiExpression[] operands = polyadicExpression.getOperands();
final PsiReferenceExpression referenceExpression =
getReferenceFromInstanceofExpression(operands[0]);
if (referenceExpression == null) {
return null;
}
for (int i = 1, operandsLength = operands.length; i < operandsLength; i++) {
if (!referencesEqual(
referenceExpression, getReferenceFromInstanceofExpression(operands[i]))) {
return null;
}
}
return referenceExpression;
} else {
return null;
}
}
public static boolean areParenthesesNeeded(
PsiExpression expression,
PsiExpression parentExpression,
boolean ignoreClarifyingParentheses) {
if (parentExpression instanceof PsiParenthesizedExpression
|| parentExpression instanceof PsiArrayInitializerExpression) {
return false;
}
final int parentPrecedence = getPrecedence(parentExpression);
final int childPrecedence = getPrecedence(expression);
if (parentPrecedence > childPrecedence) {
if (ignoreClarifyingParentheses) {
if (expression instanceof PsiPolyadicExpression) {
if (parentExpression instanceof PsiPolyadicExpression
|| parentExpression instanceof PsiConditionalExpression
|| parentExpression instanceof PsiInstanceOfExpression) {
return true;
}
} else if (expression instanceof PsiInstanceOfExpression) {
return true;
}
}
return false;
}
if (parentExpression instanceof PsiPolyadicExpression
&& expression instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression parentPolyadicExpression =
(PsiPolyadicExpression) parentExpression;
final PsiType parentType = parentPolyadicExpression.getType();
if (parentType == null) {
return true;
}
final PsiPolyadicExpression childPolyadicExpression = (PsiPolyadicExpression) expression;
final PsiType childType = childPolyadicExpression.getType();
if (!parentType.equals(childType)) {
return true;
}
if (childType.equalsToText(CommonClassNames.JAVA_LANG_STRING)
&& !PsiTreeUtil.isAncestor(
parentPolyadicExpression.getOperands()[0], childPolyadicExpression, true)) {
final PsiExpression[] operands = childPolyadicExpression.getOperands();
for (PsiExpression operand : operands) {
if (!childType.equals(operand.getType())) {
return true;
}
}
} else if (childType.equals(PsiType.BOOLEAN)) {
final PsiExpression[] operands = childPolyadicExpression.getOperands();
for (PsiExpression operand : operands) {
if (!PsiType.BOOLEAN.equals(operand.getType())) {
return true;
}
}
}
final IElementType parentOperator = parentPolyadicExpression.getOperationTokenType();
final IElementType childOperator = childPolyadicExpression.getOperationTokenType();
if (ignoreClarifyingParentheses) {
if (!childOperator.equals(parentOperator)) {
return true;
}
}
final PsiExpression[] parentOperands = parentPolyadicExpression.getOperands();
if (!PsiTreeUtil.isAncestor(parentOperands[0], expression, false)) {
if (!isAssociativeOperation(parentPolyadicExpression)
|| JavaTokenType.DIV == childOperator
|| JavaTokenType.PERC == childOperator) {
return true;
}
}
} else if (parentExpression instanceof PsiConditionalExpression
&& expression instanceof PsiConditionalExpression) {
final PsiConditionalExpression conditionalExpression =
(PsiConditionalExpression) parentExpression;
final PsiExpression condition = conditionalExpression.getCondition();
return PsiTreeUtil.isAncestor(condition, expression, true);
}
return parentPrecedence < childPrecedence;
}
private static void removeParensFromParenthesizedExpression(
@NotNull PsiParenthesizedExpression parenthesizedExpression,
boolean ignoreClarifyingParentheses) {
final PsiExpression body = parenthesizedExpression.getExpression();
if (body == null) {
parenthesizedExpression.delete();
return;
}
final PsiElement parent = parenthesizedExpression.getParent();
if (!(parent instanceof PsiExpression)
|| parent instanceof PsiParenthesizedExpression
|| parent instanceof PsiArrayInitializerExpression) {
final PsiExpression newExpression = (PsiExpression) parenthesizedExpression.replace(body);
removeParentheses(newExpression, ignoreClarifyingParentheses);
return;
} else if (parent instanceof PsiArrayAccessExpression) {
final PsiArrayAccessExpression arrayAccessExpression = (PsiArrayAccessExpression) parent;
if (parenthesizedExpression == arrayAccessExpression.getIndexExpression()) {
// use addAfter() + delete() instead of replace() to
// workaround automatic insertion of parentheses by psi
final PsiExpression newExpression =
(PsiExpression) parent.addAfter(body, parenthesizedExpression);
parenthesizedExpression.delete();
removeParentheses(newExpression, ignoreClarifyingParentheses);
return;
}
}
final PsiExpression parentExpression = (PsiExpression) parent;
final int parentPrecedence = getPrecedence(parentExpression);
final int childPrecedence = getPrecedence(body);
if (parentPrecedence < childPrecedence) {
final PsiElement bodyParent = body.getParent();
final PsiParenthesizedExpression newParenthesizedExpression =
(PsiParenthesizedExpression) parenthesizedExpression.replace(bodyParent);
final PsiExpression expression = newParenthesizedExpression.getExpression();
if (expression != null) {
removeParentheses(expression, ignoreClarifyingParentheses);
}
} else if (parentPrecedence == childPrecedence) {
if (parentExpression instanceof PsiPolyadicExpression
&& body instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression parentPolyadicExpression =
(PsiPolyadicExpression) parentExpression;
final IElementType parentOperator = parentPolyadicExpression.getOperationTokenType();
final PsiPolyadicExpression bodyPolyadicExpression = (PsiPolyadicExpression) body;
final IElementType bodyOperator = bodyPolyadicExpression.getOperationTokenType();
final PsiType parentType = parentPolyadicExpression.getType();
final PsiType bodyType = body.getType();
if (parentType != null
&& parentType.equals(bodyType)
&& parentOperator.equals(bodyOperator)) {
final PsiExpression[] parentOperands = parentPolyadicExpression.getOperands();
if (PsiTreeUtil.isAncestor(parentOperands[0], body, true)
|| isCommutativeOperator(bodyOperator)) {
// use addAfter() + delete() instead of replace() to
// workaround automatic insertion of parentheses by psi
final PsiExpression newExpression =
(PsiExpression) parent.addAfter(body, parenthesizedExpression);
parenthesizedExpression.delete();
removeParentheses(newExpression, ignoreClarifyingParentheses);
return;
}
}
if (ignoreClarifyingParentheses) {
if (parentOperator.equals(bodyOperator)) {
removeParentheses(body, ignoreClarifyingParentheses);
}
} else {
final PsiExpression newExpression = (PsiExpression) parenthesizedExpression.replace(body);
removeParentheses(newExpression, ignoreClarifyingParentheses);
}
} else {
final PsiExpression newExpression = (PsiExpression) parenthesizedExpression.replace(body);
removeParentheses(newExpression, ignoreClarifyingParentheses);
}
} else {
if (ignoreClarifyingParentheses
&& parent instanceof PsiPolyadicExpression
&& (body instanceof PsiPolyadicExpression || body instanceof PsiInstanceOfExpression)) {
removeParentheses(body, ignoreClarifyingParentheses);
} else {
final PsiExpression newExpression = (PsiExpression) parenthesizedExpression.replace(body);
removeParentheses(newExpression, ignoreClarifyingParentheses);
}
}
}