mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
deprecate PsiBinaryExpression, cleanup getOperationSign
This commit is contained in:
+2
-2
@@ -801,7 +801,7 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder {
|
||||
|
||||
final Evaluator operandEvaluator = myResult;
|
||||
|
||||
final IElementType operation = expression.getOperationSign().getTokenType();
|
||||
final IElementType operation = expression.getOperationTokenType();
|
||||
final PsiType operandType = operandExpression.getType();
|
||||
@Nullable final PsiType unboxedOperandType = PsiPrimitiveType.getUnboxedType(operandType);
|
||||
|
||||
@@ -837,7 +837,7 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder {
|
||||
@Nullable
|
||||
final PsiType unboxedOperandType = PsiPrimitiveType.getUnboxedType(operandType);
|
||||
|
||||
final IElementType operation = expression.getOperationSign().getTokenType();
|
||||
final IElementType operation = expression.getOperationTokenType();
|
||||
|
||||
if(operation == JavaTokenType.PLUSPLUS || operation == JavaTokenType.MINUSMINUS) {
|
||||
try {
|
||||
|
||||
@@ -476,7 +476,7 @@ public class ExpectedTypesProvider {
|
||||
type = ((PsiAnonymousClass)resolved).getBaseClassType();
|
||||
}
|
||||
}
|
||||
final int kind = assignment.getOperationSign().getTokenType() != JavaTokenType.EQ
|
||||
final int kind = assignment.getOperationTokenType() != JavaTokenType.EQ
|
||||
? ExpectedTypeInfo.TYPE_STRICTLY
|
||||
: ExpectedTypeInfo.TYPE_OR_SUPERTYPE;
|
||||
ExpectedTypeInfoImpl info = createInfoImpl(type, kind, type, TailType.NONE);
|
||||
@@ -567,7 +567,6 @@ public class ExpectedTypesProvider {
|
||||
|
||||
PsiExpression op1 = expr.getLOperand();
|
||||
PsiExpression op2 = expr.getROperand();
|
||||
PsiJavaToken sign = expr.getOperationSign();
|
||||
if (myForCompletion && op1.equals(myExpr)) {
|
||||
final MyParentVisitor visitor = new MyParentVisitor(expr, myForCompletion, myClassProvider, myVoidable, myUsedAfter);
|
||||
myExpr = (PsiExpression)myExpr.getParent();
|
||||
@@ -583,7 +582,7 @@ public class ExpectedTypesProvider {
|
||||
PsiExpression anotherExpr = op1.equals(myExpr) ? op2 : op1;
|
||||
PsiType anotherType = anotherExpr != null ? anotherExpr.getType() : null;
|
||||
PsiElementFactory factory = JavaPsiFacade.getInstance(expr.getProject()).getElementFactory();
|
||||
IElementType i = sign.getTokenType();
|
||||
IElementType i = expr.getOperationTokenType();
|
||||
if (i == JavaTokenType.MINUS ||
|
||||
i == JavaTokenType.ASTERISK ||
|
||||
i == JavaTokenType.DIV ||
|
||||
@@ -689,8 +688,7 @@ public class ExpectedTypesProvider {
|
||||
}
|
||||
|
||||
@Override public void visitPrefixExpression(PsiPrefixExpression expr) {
|
||||
PsiJavaToken sign = expr.getOperationSign();
|
||||
IElementType i = sign.getTokenType();
|
||||
IElementType i = expr.getOperationTokenType();
|
||||
final PsiType type = expr.getType();
|
||||
final TailType tailType = expr.getParent() instanceof PsiAssignmentExpression && ((PsiAssignmentExpression) expr.getParent()).getRExpression() == expr ?
|
||||
getAssignmentRValueTailType((PsiAssignmentExpression) expr.getParent()) :
|
||||
|
||||
+1
-2
@@ -315,8 +315,7 @@ public class SimplifyBooleanExpressionFix implements IntentionAction {
|
||||
PsiExpression operand = expression.getOperand();
|
||||
Boolean constBoolean = getConstBoolean(operand);
|
||||
if (constBoolean == null) return;
|
||||
PsiJavaToken operationSign = expression.getOperationSign();
|
||||
IElementType tokenType = operationSign.getTokenType();
|
||||
IElementType tokenType = expression.getOperationTokenType();
|
||||
if (JavaTokenType.EXCL == tokenType) {
|
||||
if (!markAndCheckCreateResult()) {
|
||||
return;
|
||||
|
||||
@@ -1399,7 +1399,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor {
|
||||
PsiType type = expression.getType();
|
||||
PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(type);
|
||||
generateBoxingUnboxingInstructionFor(operand, unboxed == null ? type : unboxed);
|
||||
if (expression.getOperationSign().getTokenType() == JavaTokenType.EXCL) {
|
||||
if (expression.getOperationTokenType() == JavaTokenType.EXCL) {
|
||||
addInstruction(new NotInstruction());
|
||||
}
|
||||
else {
|
||||
|
||||
@@ -1278,7 +1278,7 @@ class ControlFlowAnalyzer extends JavaJspElementVisitor {
|
||||
if (myAssignmentTargetsAreElements)
|
||||
startElement(lExpr);
|
||||
|
||||
if (expression.getOperationSign().getTokenType() != JavaTokenType.EQ) {
|
||||
if (expression.getOperationTokenType() != JavaTokenType.EQ) {
|
||||
generateReadInstruction(variable);
|
||||
}
|
||||
generateWriteInstruction(variable);
|
||||
@@ -1488,7 +1488,7 @@ class ControlFlowAnalyzer extends JavaJspElementVisitor {
|
||||
@Override public void visitPostfixExpression(PsiPostfixExpression expression) {
|
||||
startElement(expression);
|
||||
|
||||
IElementType op = expression.getOperationSign().getTokenType();
|
||||
IElementType op = expression.getOperationTokenType();
|
||||
PsiExpression operand = expression.getOperand();
|
||||
operand.accept(this);
|
||||
if (op == JavaTokenType.PLUSPLUS || op == JavaTokenType.MINUSMINUS) {
|
||||
@@ -1508,7 +1508,7 @@ class ControlFlowAnalyzer extends JavaJspElementVisitor {
|
||||
|
||||
PsiExpression operand = expression.getOperand();
|
||||
if (operand != null) {
|
||||
IElementType operationSign = expression.getOperationSign().getTokenType();
|
||||
IElementType operationSign = expression.getOperationTokenType();
|
||||
if (operationSign == JavaTokenType.EXCL) {
|
||||
// negation inverts jump targets
|
||||
PsiElement topStartStatement = myStartStatementStack.peekElement();
|
||||
|
||||
+1
-1
@@ -69,7 +69,7 @@ public class PsiBinaryExpressionImpl extends ExpressionPsiElement implements Psi
|
||||
PsiExpression rOperand = param.getROperand();
|
||||
if (rOperand == null) return null;
|
||||
PsiType rType = rOperand.getType();
|
||||
IElementType sign = param.getOperationSign().getNode().getElementType();
|
||||
IElementType sign = param.getOperationTokenType();
|
||||
// optimization: if we can calculate type based on right type only
|
||||
PsiType type = TypeConversionUtil.calcTypeForBinaryExpression(null, rType, sign, false);
|
||||
if (type != TypeConversionUtil.NULL_TYPE) return type;
|
||||
|
||||
+1
-2
@@ -18,7 +18,6 @@ package com.intellij.psi.impl.source.tree.java;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.impl.source.SourceTreeToPsiMap;
|
||||
import com.intellij.psi.impl.source.tree.ChildRole;
|
||||
import com.intellij.psi.impl.source.tree.ElementType;
|
||||
import com.intellij.psi.impl.source.tree.JavaElementType;
|
||||
@@ -52,7 +51,7 @@ public class PsiPrefixExpressionImpl extends ExpressionPsiElement implements Psi
|
||||
if (operand == null) return null;
|
||||
PsiType type = operand.getType();
|
||||
if (type instanceof PsiClassType) type = PsiPrimitiveType.getUnboxedType(type);
|
||||
IElementType opCode = SourceTreeToPsiMap.psiElementToTree(getOperationSign()).getElementType();
|
||||
IElementType opCode = getOperationTokenType();
|
||||
if (opCode == JavaTokenType.PLUS || opCode == JavaTokenType.MINUS || opCode == JavaTokenType.TILDE) {
|
||||
if (type == null) return null;
|
||||
return PsiType.BYTE.equals(type) || PsiType.CHAR.equals(type) || PsiType.SHORT.equals(type) ? PsiType.INT : type;
|
||||
|
||||
+4
-5
@@ -429,14 +429,13 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
|
||||
}
|
||||
}
|
||||
else if (RefactoringUtil.isPlusPlusOrMinusMinus(parent)){
|
||||
PsiJavaToken sign;
|
||||
IElementType sign;
|
||||
if (parent instanceof PsiPrefixExpression){
|
||||
sign = ((PsiPrefixExpression)parent).getOperationSign();
|
||||
sign = ((PsiPrefixExpression)parent).getOperationTokenType();
|
||||
}
|
||||
else{
|
||||
sign = ((PsiPostfixExpression)parent).getOperationSign();
|
||||
sign = ((PsiPostfixExpression)parent).getOperationTokenType();
|
||||
}
|
||||
IElementType tokenType = sign.getTokenType();
|
||||
|
||||
PsiExpression getExpr = expr;
|
||||
if (processGet){
|
||||
@@ -448,7 +447,7 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
|
||||
}
|
||||
|
||||
@NonNls String text;
|
||||
if (tokenType == JavaTokenType.PLUSPLUS){
|
||||
if (sign == JavaTokenType.PLUSPLUS){
|
||||
text = "a+1";
|
||||
}
|
||||
else{
|
||||
|
||||
@@ -148,8 +148,7 @@ public class PropertyUtils {
|
||||
return null;
|
||||
}
|
||||
final PsiAssignmentExpression assignment = (PsiAssignmentExpression)possibleAssignment;
|
||||
final PsiJavaToken sign = assignment.getOperationSign();
|
||||
if (!JavaTokenType.EQ.equals(sign.getTokenType())) {
|
||||
if (!JavaTokenType.EQ.equals(assignment.getOperationTokenType())) {
|
||||
return null;
|
||||
}
|
||||
final PsiExpression lhs = assignment.getLExpression();
|
||||
|
||||
@@ -149,8 +149,8 @@ public class TypeEvaluator {
|
||||
else if (expr instanceof PsiBinaryExpression) {
|
||||
final PsiExpression lOperand = ((PsiBinaryExpression)expr).getLOperand();
|
||||
final PsiExpression rOperand = ((PsiBinaryExpression)expr).getROperand();
|
||||
final PsiJavaToken operationSign = ((PsiBinaryExpression)expr).getOperationSign();
|
||||
return TypeConversionUtil.calcTypeForBinaryExpression(evaluateType(lOperand), evaluateType(rOperand), operationSign.getTokenType(),
|
||||
return TypeConversionUtil.calcTypeForBinaryExpression(evaluateType(lOperand), evaluateType(rOperand),
|
||||
((PsiBinaryExpression)expr).getOperationTokenType(),
|
||||
true);
|
||||
}
|
||||
else if (expr instanceof PsiPostfixExpression) {
|
||||
|
||||
@@ -528,8 +528,8 @@ public class RefactoringUtil {
|
||||
|
||||
public static boolean isPlusPlusOrMinusMinus(PsiElement element) {
|
||||
if (element instanceof PsiPrefixExpression) {
|
||||
PsiJavaToken operandSign = ((PsiPrefixExpression)element).getOperationSign();
|
||||
return operandSign.getTokenType() == JavaTokenType.PLUSPLUS || operandSign.getTokenType() == JavaTokenType.MINUSMINUS;
|
||||
return ((PsiPrefixExpression)element).getOperationTokenType() == JavaTokenType.PLUSPLUS ||
|
||||
((PsiPrefixExpression)element).getOperationTokenType() == JavaTokenType.MINUSMINUS;
|
||||
}
|
||||
else if (element instanceof PsiPostfixExpression) {
|
||||
IElementType operandTokenType = ((PsiPostfixExpression)element).getOperationTokenType();
|
||||
|
||||
@@ -59,8 +59,7 @@ public class CodeInsightServicesUtil {
|
||||
}
|
||||
else if (booleanExpression instanceof PsiPrefixExpression) {
|
||||
PsiPrefixExpression expression = (PsiPrefixExpression)booleanExpression;
|
||||
PsiJavaToken operationSign = expression.getOperationSign();
|
||||
if (operationSign.getTokenType() == JavaTokenType.EXCL) {
|
||||
if (expression.getOperationTokenType() == JavaTokenType.EXCL) {
|
||||
PsiExpression operand = expression.getOperand();
|
||||
if (operand instanceof PsiParenthesizedExpression) {
|
||||
operand = ((PsiParenthesizedExpression)operand).getExpression();
|
||||
|
||||
@@ -21,7 +21,9 @@ import com.intellij.psi.tree.IElementType;
|
||||
|
||||
/**
|
||||
* Represents a Java binary expression (addition, multiplication and so on).
|
||||
* @deprecated Use {@link PsiPolyadicExpression} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public interface PsiBinaryExpression extends PsiExpression, PsiPolyadicExpression {
|
||||
/**
|
||||
* Returns the left operand of the expression.
|
||||
|
||||
+1
-2
@@ -129,8 +129,7 @@ public class BooleanMethodIsAlwaysInvertedInspection extends GlobalJavaInspectio
|
||||
final PsiPrefixExpression prefixExpression = PsiTreeUtil.getParentOfType(methodExpression, PsiPrefixExpression.class);
|
||||
if (methodExpression.getQualifierExpression() instanceof PsiSuperExpression) return true; //don't flag super calls
|
||||
if (prefixExpression != null) {
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.EXCL)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
+1
-2
@@ -83,8 +83,7 @@ public class AssignmentToCollectionFieldFromParameterInspection
|
||||
if(!(rhs instanceof PsiReferenceExpression)){
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.EQ)){
|
||||
return;
|
||||
}
|
||||
|
||||
+1
-2
@@ -71,8 +71,7 @@ public class AssignmentToDateFieldFromParameterInspection
|
||||
@Override public void visitAssignmentExpression(
|
||||
@NotNull PsiAssignmentExpression expression) {
|
||||
super.visitAssignmentExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!JavaTokenType.EQ.equals(tokenType)) {
|
||||
return;
|
||||
}
|
||||
|
||||
+2
-4
@@ -86,8 +86,7 @@ public class AssignmentToForLoopParameterInspection
|
||||
@Override public void visitPrefixExpression(
|
||||
@NotNull PsiPrefixExpression expression) {
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
@@ -103,8 +102,7 @@ public class AssignmentToForLoopParameterInspection
|
||||
@Override public void visitPostfixExpression(
|
||||
@NotNull PsiPostfixExpression expression) {
|
||||
super.visitPostfixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
|
||||
+1
-2
@@ -128,8 +128,7 @@ public class AssignmentToMethodParameterInspection
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
|
||||
+2
-4
@@ -57,8 +57,7 @@ public class AssignmentToStaticFieldFromInstanceMethodInspection
|
||||
|
||||
@Override public void visitPrefixExpression(
|
||||
@NotNull PsiPrefixExpression expression){
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
@@ -72,8 +71,7 @@ public class AssignmentToStaticFieldFromInstanceMethodInspection
|
||||
|
||||
@Override public void visitPostfixExpression(
|
||||
@NotNull PsiPostfixExpression expression){
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
|
||||
+1
-2
@@ -154,8 +154,7 @@ public class ReplaceAssignmentWithOperatorAssignmentInspection
|
||||
@Override public void visitAssignmentExpression(@NotNull
|
||||
PsiAssignmentExpression assignment){
|
||||
super.visitAssignmentExpression(assignment);
|
||||
final PsiJavaToken sign = assignment.getOperationSign();
|
||||
final IElementType assignmentTokenType = sign.getTokenType();
|
||||
final IElementType assignmentTokenType = assignment.getOperationTokenType();
|
||||
if(!assignmentTokenType.equals(JavaTokenType.EQ)){
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -43,9 +43,7 @@ public class IncompatibleMaskInspection extends BaseInspection {
|
||||
public String buildErrorString(Object... infos){
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) infos[0];
|
||||
final PsiJavaToken operationSign =
|
||||
binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.EQEQ)){
|
||||
return InspectionGadgetsBundle.message(
|
||||
"incompatible.mask.operation.problem.descriptor.always.false");
|
||||
@@ -105,8 +103,7 @@ public class IncompatibleMaskInspection extends BaseInspection {
|
||||
private static boolean isIncompatibleMask(
|
||||
PsiBinaryExpression maskExpression,
|
||||
PsiExpression constantExpression){
|
||||
final PsiJavaToken sign = maskExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = maskExpression.getOperationTokenType();
|
||||
final Object constantValue =
|
||||
ConstantExpressionUtil.computeCastTo(constantExpression,
|
||||
PsiType.LONG);
|
||||
@@ -156,8 +153,7 @@ public class IncompatibleMaskInspection extends BaseInspection {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.OR) &&
|
||||
!tokenType.equals(JavaTokenType.AND)){
|
||||
return false;
|
||||
|
||||
+1
-2
@@ -85,8 +85,7 @@ public class PointlessBitwiseExpressionInspection extends BaseInspection {
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
assert rhs != null;
|
||||
if(tokenType.equals(JavaTokenType.AND)){
|
||||
if(isZero(lhs) || isAllOnes(rhs)){
|
||||
|
||||
+2
-4
@@ -64,8 +64,7 @@ public class NonShortCircuitBooleanInspection extends BaseInspection {
|
||||
(PsiBinaryExpression) descriptor.getPsiElement();
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiExpression rhs = expression.getROperand();
|
||||
final PsiJavaToken operationSign = expression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
assert rhs != null;
|
||||
final String newExpression = lhs.getText() +
|
||||
getShortCircuitOperand(tokenType) + rhs.getText();
|
||||
@@ -96,8 +95,7 @@ public class NonShortCircuitBooleanInspection extends BaseInspection {
|
||||
if(!(expression.getROperand() != null)){
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.AND) &&
|
||||
!tokenType.equals(JavaTokenType.OR)) {
|
||||
return;
|
||||
|
||||
@@ -75,8 +75,7 @@ public class ObjectToStringInspection extends BaseInspection {
|
||||
if(!WellFormednessUtils.isWellFormed(expression)) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSEQ)) {
|
||||
return;
|
||||
}
|
||||
|
||||
+1
-2
@@ -66,8 +66,7 @@ public class SubtractionInCompareToInspection extends BaseInspection {
|
||||
if(rhs == null){
|
||||
return false;
|
||||
}
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
return tokenType.equals(JavaTokenType.MINUS);
|
||||
}
|
||||
}
|
||||
|
||||
+1
-2
@@ -133,8 +133,7 @@ public class BooleanFieldAlwaysNegatedInspection extends BaseGlobalInspection {
|
||||
private static boolean isInvertedFieldRead(PsiReferenceExpression referenceExpression) {
|
||||
final PsiPrefixExpression prefixExpression = PsiTreeUtil.getParentOfType(referenceExpression, PsiPrefixExpression.class);
|
||||
if (prefixExpression != null) {
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.EXCL)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
+1
-2
@@ -119,8 +119,7 @@ public class DuplicateBooleanBranchInspection extends BaseInspection {
|
||||
if (condition instanceof PsiBinaryExpression) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType testTokeType = sign.getTokenType();
|
||||
final IElementType testTokeType = binaryExpression.getOperationTokenType();
|
||||
if (testTokeType.equals(tokenType)) {
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
collectConditions(lhs, conditions, tokenType);
|
||||
|
||||
+1
-2
@@ -144,8 +144,7 @@ public class DuplicateConditionInspection extends BaseInspection {
|
||||
if (condition instanceof PsiBinaryExpression) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (JavaTokenType.OROR.equals(tokenType)) {
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
collectConditionsForExpression(lhs, conditions);
|
||||
|
||||
+1
-2
@@ -176,8 +176,7 @@ public class LoopConditionNotUpdatedInsideLoopInspection
|
||||
} else if (condition instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)condition;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (JavaTokenType.EXCL.equals(tokenType) ||
|
||||
JavaTokenType.PLUS.equals(tokenType) ||
|
||||
JavaTokenType.MINUS.equals(tokenType)) {
|
||||
|
||||
+1
-2
@@ -242,8 +242,7 @@ public class OverlyComplexBooleanExpressionInspection
|
||||
} else if (expression instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression) expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
return tokenType.equals(JavaTokenType.EXCL);
|
||||
} else if (expression instanceof PsiParenthesizedExpression) {
|
||||
final PsiParenthesizedExpression parenthesizedExpression =
|
||||
|
||||
+6
-9
@@ -100,14 +100,13 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
|
||||
@Nullable
|
||||
private String calculateSimplifiedBinaryExpression(
|
||||
PsiBinaryExpression expression){
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
|
||||
final PsiExpression rhs = expression.getROperand();
|
||||
if(rhs == null){
|
||||
return null;
|
||||
}
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
final String rhsText = rhs.getText();
|
||||
final String lhsText = lhs.getText();
|
||||
if(tokenType.equals(JavaTokenType.ANDAND) ||
|
||||
@@ -156,9 +155,8 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
|
||||
if(ComparisonUtils.isComparison(exp)){
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) exp;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
assert rhs != null;
|
||||
@@ -284,9 +282,8 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
|
||||
@Override public void visitPrefixExpression(
|
||||
@NotNull PsiPrefixExpression expression){
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final PsiExpression operand = expression.getOperand();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final PsiExpression operand = expression.getOperand();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!(!tokenType.equals(JavaTokenType.EXCL) ||
|
||||
!notExpressionIsPointless(operand))){
|
||||
registerError(expression, expression);
|
||||
|
||||
@@ -386,10 +386,8 @@ public class TrivialIfInspection extends BaseInspection {
|
||||
final PsiAssignmentExpression elseExpression =
|
||||
(PsiAssignmentExpression)
|
||||
elseExpressionStatement.getExpression();
|
||||
final PsiJavaToken thenSign = thenExpression.getOperationSign();
|
||||
final PsiJavaToken elseSign = elseExpression.getOperationSign();
|
||||
final IElementType thenTokenType = thenSign.getTokenType();
|
||||
if (!thenTokenType.equals(elseSign.getTokenType())) {
|
||||
final IElementType thenTokenType = thenExpression.getOperationTokenType();
|
||||
if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression thenLhs = thenExpression.getLExpression();
|
||||
@@ -419,10 +417,8 @@ public class TrivialIfInspection extends BaseInspection {
|
||||
final PsiAssignmentExpression elseExpression =
|
||||
(PsiAssignmentExpression)
|
||||
elseExpressionStatement.getExpression();
|
||||
final PsiJavaToken thenSign = thenExpression.getOperationSign();
|
||||
final PsiJavaToken elseSign = elseExpression.getOperationSign();
|
||||
final IElementType thenTokenType = thenSign.getTokenType();
|
||||
if (!thenTokenType.equals(elseSign.getTokenType())) {
|
||||
final IElementType thenTokenType = thenExpression.getOperationTokenType();
|
||||
if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression thenLhs = thenExpression.getLExpression();
|
||||
@@ -461,10 +457,8 @@ public class TrivialIfInspection extends BaseInspection {
|
||||
final PsiAssignmentExpression elseExpression =
|
||||
(PsiAssignmentExpression)
|
||||
elseExpressionStatement.getExpression();
|
||||
final PsiJavaToken thenSign = thenExpression.getOperationSign();
|
||||
final PsiJavaToken elseSign = elseExpression.getOperationSign();
|
||||
final IElementType thenTokenType = thenSign.getTokenType();
|
||||
if (!thenTokenType.equals(elseSign.getTokenType())) {
|
||||
final IElementType thenTokenType = thenExpression.getOperationTokenType();
|
||||
if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression thenLhs = thenExpression.getLExpression();
|
||||
@@ -503,10 +497,8 @@ public class TrivialIfInspection extends BaseInspection {
|
||||
final PsiAssignmentExpression elseExpression =
|
||||
(PsiAssignmentExpression)
|
||||
elseExpressionStatement.getExpression();
|
||||
final PsiJavaToken thenSign = thenExpression.getOperationSign();
|
||||
final PsiJavaToken elseSign = elseExpression.getOperationSign();
|
||||
final IElementType thenTokenType = thenSign.getTokenType();
|
||||
if (!thenTokenType.equals(elseSign.getTokenType())) {
|
||||
final IElementType thenTokenType = thenExpression.getOperationTokenType();
|
||||
if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression thenLhs = thenExpression.getLExpression();
|
||||
|
||||
+2
-6
@@ -238,9 +238,7 @@ public class ConstantValueVariableUseInspection extends BaseInspection {
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(prefixExpression);
|
||||
final PsiJavaToken operationSign =
|
||||
prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
@@ -265,9 +263,7 @@ public class ConstantValueVariableUseInspection extends BaseInspection {
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(postfixExpression);
|
||||
final PsiJavaToken operationSign =
|
||||
postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
|
||||
+1
-2
@@ -185,8 +185,7 @@ public class ReuseOfLocalVariableInspection
|
||||
if(variable.getInitializer() == null){
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = assignment.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = assignment.getOperationTokenType();
|
||||
if(!JavaTokenType.EQ.equals(tokenType)){
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -43,8 +43,7 @@ public class EqualityToEqualsFix extends InspectionGadgetsFix {
|
||||
return;
|
||||
}
|
||||
boolean negated=false;
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (JavaTokenType.NE.equals(tokenType)) {
|
||||
negated = true;
|
||||
}
|
||||
|
||||
@@ -477,8 +477,7 @@ public class SerialVersionUIDBuilder extends JavaRecursiveElementVisitor{
|
||||
} else if(parent instanceof PsiPostfixExpression){
|
||||
final PsiPostfixExpression postfixExpression =
|
||||
(PsiPostfixExpression) parent;
|
||||
final PsiJavaToken operationSign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS)){
|
||||
name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
|
||||
"08";
|
||||
@@ -488,8 +487,7 @@ public class SerialVersionUIDBuilder extends JavaRecursiveElementVisitor{
|
||||
}
|
||||
} else if(parent instanceof PsiPrefixExpression){
|
||||
final PsiPrefixExpression prefixExpression = (PsiPrefixExpression) parent;
|
||||
final PsiJavaToken operationSign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS)){
|
||||
name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
|
||||
"04";
|
||||
|
||||
+1
-2
@@ -136,8 +136,7 @@ public class NonThreadSafeLazyInitializationInspection
|
||||
}
|
||||
final PsiBinaryExpression comparison =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = comparison.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = comparison.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.EQEQ)){
|
||||
return false;
|
||||
}
|
||||
|
||||
+2
-3
@@ -165,8 +165,7 @@ public class StringConcatenationInspection extends BaseInspection {
|
||||
if(rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!JavaTokenType.PLUS.equals(tokenType)) {
|
||||
return;
|
||||
}
|
||||
@@ -261,7 +260,7 @@ public class StringConcatenationInspection extends BaseInspection {
|
||||
if (NonNlsUtils.isNonNlsAnnotatedUse(expression)) {
|
||||
return;
|
||||
}
|
||||
registerError(sign, expression);
|
||||
registerError(expression.getOperationSign(), expression);
|
||||
}
|
||||
|
||||
private boolean isInsideAnnotation(PsiBinaryExpression expression) {
|
||||
|
||||
+6
-10
@@ -66,10 +66,9 @@ public class MultiplyOrDivideByPowerOfTwoInspection
|
||||
if (expression instanceof PsiAssignmentExpression) {
|
||||
final PsiAssignmentExpression exp =
|
||||
(PsiAssignmentExpression)expression;
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
lhs = exp.getLExpression();
|
||||
lhs = exp.getLExpression();
|
||||
rhs = exp.getRExpression();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.ASTERISKEQ)) {
|
||||
operator = "<<=";
|
||||
} else {
|
||||
@@ -77,10 +76,9 @@ public class MultiplyOrDivideByPowerOfTwoInspection
|
||||
}
|
||||
} else {
|
||||
final PsiBinaryExpression exp = (PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
lhs = exp.getLOperand();
|
||||
lhs = exp.getLOperand();
|
||||
rhs = exp.getROperand();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.ASTERISK)) {
|
||||
operator = "<<";
|
||||
} else {
|
||||
@@ -159,9 +157,8 @@ public class MultiplyOrDivideByPowerOfTwoInspection
|
||||
if (rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.ASTERISK)) {
|
||||
if (!checkDivision || !tokenType.equals(JavaTokenType.DIV)) {
|
||||
return;
|
||||
@@ -186,8 +183,7 @@ public class MultiplyOrDivideByPowerOfTwoInspection
|
||||
if (!WellFormednessUtils.isWellFormed(expression)) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.ASTERISKEQ)) {
|
||||
if (!checkDivision || !tokenType.equals(JavaTokenType.DIVEQ)) {
|
||||
return;
|
||||
|
||||
+4
-10
@@ -245,9 +245,8 @@ public class SimplifiableIfStatementInspection extends BaseInspection {
|
||||
} else if (ComparisonUtils.isComparison(expression)) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if (ParenthesesUtils.getPrecedence(expression) > precedence) {
|
||||
@@ -390,13 +389,8 @@ public class SimplifiableIfStatementInspection extends BaseInspection {
|
||||
(PsiExpressionStatement)elseBranch;
|
||||
final PsiAssignmentExpression elseExpression =
|
||||
(PsiAssignmentExpression)elseStatement.getExpression();
|
||||
final PsiJavaToken thenOperationSign =
|
||||
thenExpression.getOperationSign();
|
||||
final IElementType thenTokenType = thenOperationSign.getTokenType();
|
||||
final PsiJavaToken elseOperationSign =
|
||||
elseExpression.getOperationSign();
|
||||
final IElementType elseTokenType = elseOperationSign.getTokenType();
|
||||
if (!thenTokenType.equals(elseTokenType)) {
|
||||
final IElementType elseTokenType = elseExpression.getOperationTokenType();
|
||||
if (!thenExpression.getOperationTokenType().equals(elseTokenType)) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression thenRhs = thenExpression.getRExpression();
|
||||
|
||||
@@ -148,9 +148,7 @@ public class AutoUnboxingInspection extends BaseInspection {
|
||||
!unboxedType.equalsToText("boolean") ) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)parent;
|
||||
final PsiJavaToken operationSign =
|
||||
prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (JavaTokenType.PLUSPLUS.equals(tokenType)) {
|
||||
replaceExpression(prefixExpression,
|
||||
expressionText + '=' + newExpressionText + "+1");
|
||||
@@ -161,9 +159,7 @@ public class AutoUnboxingInspection extends BaseInspection {
|
||||
} else if (parent instanceof PsiPostfixExpression) {
|
||||
final PsiPostfixExpression postfixExpression =
|
||||
(PsiPostfixExpression)parent;
|
||||
final PsiJavaToken operationSign =
|
||||
postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
final PsiElement grandParent = postfixExpression.getParent();
|
||||
if (grandParent instanceof PsiExpressionStatement) {
|
||||
if (JavaTokenType.PLUSPLUS.equals(tokenType)) {
|
||||
|
||||
+1
-3
@@ -693,9 +693,7 @@ public class SimplifiableJUnitAssertionInspection extends BaseInspection {
|
||||
if (expression instanceof PsiBinaryExpression) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign =
|
||||
binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.EQEQ)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -25,8 +25,7 @@ class NegationCountVisitor extends JavaRecursiveElementVisitor {
|
||||
|
||||
@Override public void visitBinaryExpression(@NotNull PsiBinaryExpression expression) {
|
||||
super.visitBinaryExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.NE)) {
|
||||
m_count++;
|
||||
}
|
||||
@@ -38,8 +37,7 @@ class NegationCountVisitor extends JavaRecursiveElementVisitor {
|
||||
|
||||
@Override public void visitPrefixExpression(@NotNull PsiPrefixExpression expression) {
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (sign.getTokenType().equals(JavaTokenType.EXCL)) {
|
||||
if (expression.getOperationTokenType().equals(JavaTokenType.EXCL)) {
|
||||
m_count++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1245,8 +1245,7 @@ public class ForCanBeForeachInspection extends BaseInspection{
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.LT)){
|
||||
return false;
|
||||
}
|
||||
@@ -1266,8 +1265,7 @@ public class ForCanBeForeachInspection extends BaseInspection{
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.LT)){
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -379,8 +379,7 @@ public class IfCanBeSwitchInspection extends BaseInspection {
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (JavaTokenType.OROR.equals(tokenType)) {
|
||||
extractCaseExpressions(lhs, switchExpression,
|
||||
values);
|
||||
|
||||
+13
-20
@@ -53,17 +53,16 @@ public class IndexOfReplaceableByContainsInspection
|
||||
public String buildErrorString(Object... infos) {
|
||||
final PsiBinaryExpression expression = (PsiBinaryExpression)infos[0];
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String text;
|
||||
final String text;
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
text = createContainsExpressionText(callExpression, sign, false);
|
||||
text = createContainsExpressionText(callExpression, false, expression.getOperationTokenType());
|
||||
} else {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)expression.getROperand();
|
||||
assert callExpression != null;
|
||||
text = createContainsExpressionText(callExpression, sign, true);
|
||||
text = createContainsExpressionText(callExpression, true, expression.getOperationTokenType());
|
||||
}
|
||||
return InspectionGadgetsBundle.message(
|
||||
"indexof.replaceable.by.contains.problem.descriptor", text);
|
||||
@@ -89,19 +88,18 @@ public class IndexOfReplaceableByContainsInspection
|
||||
(PsiBinaryExpression) element;
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiExpression rhs = expression.getROperand();
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String newExpressionText;
|
||||
final String newExpressionText;
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
newExpressionText =
|
||||
createContainsExpressionText(callExpression, sign,
|
||||
false);
|
||||
createContainsExpressionText(callExpression,
|
||||
false, expression.getOperationTokenType());
|
||||
} else if (rhs instanceof PsiMethodCallExpression) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)rhs;
|
||||
newExpressionText =
|
||||
createContainsExpressionText(callExpression, sign, true);
|
||||
createContainsExpressionText(callExpression, true, expression.getOperationTokenType());
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
@@ -116,10 +114,8 @@ public class IndexOfReplaceableByContainsInspection
|
||||
}
|
||||
|
||||
static String createContainsExpressionText(
|
||||
@NotNull PsiMethodCallExpression call,
|
||||
@NotNull PsiJavaToken sign,
|
||||
boolean flipped) {
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
@NotNull PsiMethodCallExpression call,
|
||||
boolean flipped, IElementType tokenType) {
|
||||
final PsiReferenceExpression methodExpression =
|
||||
call.getMethodExpression();
|
||||
final PsiExpression qualifierExpression =
|
||||
@@ -169,21 +165,19 @@ public class IndexOfReplaceableByContainsInspection
|
||||
}
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByContains(lhs, sign, rhs, false)) {
|
||||
if (canBeReplacedByContains(lhs, rhs, false, expression.getOperationTokenType())) {
|
||||
registerError(expression, expression);
|
||||
}
|
||||
} else if (rhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByContains(rhs, sign, lhs, true)) {
|
||||
if (canBeReplacedByContains(rhs, lhs, true, expression.getOperationTokenType())) {
|
||||
registerError(expression, expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean canBeReplacedByContains(
|
||||
PsiExpression lhs, PsiJavaToken sign,
|
||||
PsiExpression rhs, boolean flipped) {
|
||||
PsiExpression lhs,
|
||||
PsiExpression rhs, boolean flipped, IElementType tokenType) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
if (!isIndexOfCall(callExpression)) {
|
||||
@@ -196,7 +190,6 @@ public class IndexOfReplaceableByContainsInspection
|
||||
}
|
||||
final Integer integer = (Integer)object;
|
||||
final int constant = integer.intValue();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
if (flipped) {
|
||||
if (constant == -1 && (JavaTokenType.NE.equals(tokenType) ||
|
||||
JavaTokenType.LT.equals(tokenType) ||
|
||||
|
||||
@@ -67,8 +67,7 @@ public class BadOddnessInspection extends BaseInspection {
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression binary = (PsiBinaryExpression) exp;
|
||||
final PsiJavaToken sign = binary.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binary.getOperationTokenType();
|
||||
if (!JavaTokenType.PERC.equals(tokenType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -39,8 +39,7 @@ public class ComparisonToNaNInspection extends BaseInspection {
|
||||
@NotNull
|
||||
public String buildErrorString(Object... infos) {
|
||||
final PsiBinaryExpression comparison = (PsiBinaryExpression)infos[0];
|
||||
final PsiJavaToken sign = comparison.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = comparison.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.EQEQ)) {
|
||||
return InspectionGadgetsBundle.message(
|
||||
"comparison.to.nan.problem.descriptor1");
|
||||
@@ -87,8 +86,7 @@ public class ComparisonToNaNInspection extends BaseInspection {
|
||||
}
|
||||
assert operand != null;
|
||||
final String operandText = operand.getText();
|
||||
final PsiJavaToken sign = comparison.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = comparison.getOperationTokenType();
|
||||
final String negationString;
|
||||
if (tokenType.equals(JavaTokenType.EQEQ)) {
|
||||
negationString = "";
|
||||
|
||||
@@ -54,8 +54,7 @@ public class DivideByZeroInspection extends BaseInspection {
|
||||
if (rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.DIV) &&
|
||||
!tokenType.equals(JavaTokenType.PERC)) {
|
||||
return;
|
||||
@@ -78,8 +77,7 @@ public class DivideByZeroInspection extends BaseInspection {
|
||||
if (rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.DIVEQ)
|
||||
&& !tokenType.equals(JavaTokenType.PERCEQ)) {
|
||||
return;
|
||||
|
||||
+1
-2
@@ -243,8 +243,7 @@ public class ImplicitNumericConversionInspection extends BaseInspection {
|
||||
}
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!JavaTokenType.MINUS.equals(tokenType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
+1
-2
@@ -72,8 +72,7 @@ public class IntegerDivisionInFloatingPointContextInspection
|
||||
@Override public void visitBinaryExpression(
|
||||
@NotNull PsiBinaryExpression expression) {
|
||||
super.visitBinaryExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.DIV)) {
|
||||
return;
|
||||
}
|
||||
|
||||
+1
-2
@@ -79,8 +79,7 @@ public class IntegerMultiplicationImplicitCastToLongInspection extends
|
||||
@Override public void visitBinaryExpression(
|
||||
@NotNull PsiBinaryExpression expression) {
|
||||
super.visitBinaryExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.ASTERISK)
|
||||
&& !tokenType.equals(JavaTokenType.LTLT)) {
|
||||
return;
|
||||
|
||||
+10
-13
@@ -16,6 +16,7 @@
|
||||
package com.siyeh.ig.numeric;
|
||||
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.siyeh.InspectionGadgetsBundle;
|
||||
import com.siyeh.ig.BaseInspection;
|
||||
import com.siyeh.ig.BaseInspectionVisitor;
|
||||
@@ -37,15 +38,15 @@ public class OverlyComplexArithmeticExpressionInspection
|
||||
/** @noinspection PublicField */
|
||||
public int m_limit = TERM_LIMIT; //this is public for the DefaultJDOMExternalizer thingy
|
||||
|
||||
private static final Set<String> arithmeticTokens =
|
||||
new HashSet<String>(5);
|
||||
private static final Set<IElementType> arithmeticTokens =
|
||||
new HashSet<IElementType>(5);
|
||||
|
||||
static {
|
||||
arithmeticTokens.add("+");
|
||||
arithmeticTokens.add("-");
|
||||
arithmeticTokens.add("*");
|
||||
arithmeticTokens.add("/");
|
||||
arithmeticTokens.add("%");
|
||||
arithmeticTokens.add(JavaTokenType.PLUS);
|
||||
arithmeticTokens.add(JavaTokenType.MINUS);
|
||||
arithmeticTokens.add(JavaTokenType.ASTERISK);
|
||||
arithmeticTokens.add(JavaTokenType.DIV);
|
||||
arithmeticTokens.add(JavaTokenType.PERC);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -162,16 +163,12 @@ public class OverlyComplexArithmeticExpressionInspection
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String signText = sign.getText();
|
||||
return arithmeticTokens.contains(signText);
|
||||
return arithmeticTokens.contains(binaryExpression.getOperationTokenType());
|
||||
}
|
||||
else if (expression instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final String signText = sign.getText();
|
||||
return arithmeticTokens.contains(signText);
|
||||
return arithmeticTokens.contains(prefixExpression.getOperationTokenType());
|
||||
}
|
||||
else if (expression instanceof PsiParenthesizedExpression) {
|
||||
final PsiParenthesizedExpression parenthesizedExpression =
|
||||
|
||||
+17
-20
@@ -38,20 +38,20 @@ import java.util.Set;
|
||||
public class PointlessArithmeticExpressionInspection
|
||||
extends BaseInspection {
|
||||
|
||||
private static final Set<String> arithmeticTokens =
|
||||
new HashSet<String>(9);
|
||||
private static final Set<IElementType> arithmeticTokens =
|
||||
new HashSet<IElementType>(5);
|
||||
|
||||
static {
|
||||
arithmeticTokens.add("+");
|
||||
arithmeticTokens.add("-");
|
||||
arithmeticTokens.add("*");
|
||||
arithmeticTokens.add("/");
|
||||
arithmeticTokens.add("%");
|
||||
arithmeticTokens.add(">");
|
||||
arithmeticTokens.add("<");
|
||||
arithmeticTokens.add("<=");
|
||||
arithmeticTokens.add(">=");
|
||||
}
|
||||
static {
|
||||
arithmeticTokens.add(JavaTokenType.PLUS);
|
||||
arithmeticTokens.add(JavaTokenType.MINUS);
|
||||
arithmeticTokens.add(JavaTokenType.ASTERISK);
|
||||
arithmeticTokens.add(JavaTokenType.DIV);
|
||||
arithmeticTokens.add(JavaTokenType.PERC);
|
||||
arithmeticTokens.add(JavaTokenType.GT);
|
||||
arithmeticTokens.add(JavaTokenType.LT);
|
||||
arithmeticTokens.add(JavaTokenType.LE);
|
||||
arithmeticTokens.add(JavaTokenType.GE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @noinspection PublicField
|
||||
@@ -90,11 +90,10 @@ public class PointlessArithmeticExpressionInspection
|
||||
String calculateReplacementExpression(
|
||||
PsiExpression expression) {
|
||||
final PsiBinaryExpression exp = (PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
final PsiExpression lhs = exp.getLOperand();
|
||||
final PsiExpression lhs = exp.getLOperand();
|
||||
final PsiExpression rhs = exp.getROperand();
|
||||
assert rhs != null;
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.PLUS)) {
|
||||
if (isZero(lhs)) {
|
||||
return rhs.getText();
|
||||
@@ -169,9 +168,7 @@ public class PointlessArithmeticExpressionInspection
|
||||
PsiType.FLOAT.equals(expressionType)) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String signText = sign.getText();
|
||||
if (!arithmeticTokens.contains(signText)) {
|
||||
if (!arithmeticTokens.contains(expression.getOperationTokenType())) {
|
||||
return;
|
||||
}
|
||||
if (TypeUtils.expressionHasType(expression,
|
||||
@@ -179,7 +176,7 @@ public class PointlessArithmeticExpressionInspection
|
||||
return;
|
||||
}
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
final boolean isPointless;
|
||||
if (tokenType.equals(JavaTokenType.PLUS)) {
|
||||
isPointless = additionExpressionIsPointless(lhs, rhs);
|
||||
|
||||
+1
-2
@@ -113,8 +113,7 @@ public class LengthOneStringsInConcatenationInspection
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression binaryExp = (PsiBinaryExpression)parent;
|
||||
final PsiJavaToken sign = binaryExp.getOperationSign();
|
||||
if (!JavaTokenType.PLUS.equals(sign.getTokenType())) {
|
||||
if (!JavaTokenType.PLUS.equals(binaryExp.getOperationTokenType())) {
|
||||
return false;
|
||||
}
|
||||
final PsiExpression lhs = binaryExp.getLOperand();
|
||||
|
||||
+1
-2
@@ -562,8 +562,7 @@ public class ManualArrayCopyInspection extends BaseInspection {
|
||||
}
|
||||
final PsiAssignmentExpression assignment =
|
||||
(PsiAssignmentExpression)strippedExpression;
|
||||
final PsiJavaToken sign = assignment.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = assignment.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.EQ)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
+1
-2
@@ -160,8 +160,7 @@ public class RandomDoubleForRandomIntegerInspection
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
return JavaTokenType.ASTERISK.equals(tokenType);
|
||||
}
|
||||
|
||||
|
||||
+6
-10
@@ -98,8 +98,7 @@ public class SizeReplaceableByIsEmptyInspection extends BaseInspection {
|
||||
return;
|
||||
}
|
||||
@NonNls String newExpression = qualifierExpression.getText();
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (!JavaTokenType.EQEQ.equals(tokenType)) {
|
||||
newExpression = '!' + newExpression;
|
||||
}
|
||||
@@ -129,21 +128,19 @@ public class SizeReplaceableByIsEmptyInspection extends BaseInspection {
|
||||
}
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByIsEmpty(lhs, sign, rhs, false)) {
|
||||
if (canBeReplacedByIsEmpty(lhs, rhs, false, expression.getOperationTokenType())) {
|
||||
registerError(expression, isEmptyCall);
|
||||
}
|
||||
} else if (rhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByIsEmpty(rhs, sign, lhs, true)) {
|
||||
if (canBeReplacedByIsEmpty(rhs, lhs, true, expression.getOperationTokenType())) {
|
||||
registerError(expression, isEmptyCall);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean canBeReplacedByIsEmpty(
|
||||
PsiExpression lhs, PsiJavaToken sign, PsiExpression rhs,
|
||||
boolean flipped) {
|
||||
PsiExpression lhs, PsiExpression rhs,
|
||||
boolean flipped, IElementType tokenType) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
if (!isSizeCall(callExpression)) {
|
||||
@@ -159,8 +156,7 @@ public class SizeReplaceableByIsEmptyInspection extends BaseInspection {
|
||||
if (constant != 0) {
|
||||
return false;
|
||||
}
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
if (JavaTokenType.EQEQ.equals(tokenType)) {
|
||||
if (JavaTokenType.EQEQ.equals(tokenType)) {
|
||||
return true;
|
||||
}
|
||||
if (ignoreNegations) {
|
||||
|
||||
+1
-2
@@ -93,8 +93,7 @@ public class StringBufferToStringInConcatenationInspection
|
||||
}
|
||||
final PsiBinaryExpression parentBinary =
|
||||
(PsiBinaryExpression)parent;
|
||||
final PsiJavaToken sign = parentBinary.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = parentBinary.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUS)) {
|
||||
return;
|
||||
}
|
||||
|
||||
+1
-2
@@ -56,8 +56,7 @@ class StringVariableIsAppendedToVisitor extends JavaRecursiveElementVisitor {
|
||||
if (!variable.equals(referent)) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken operationSign = assignment.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = assignment.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.PLUSEQ)) {
|
||||
if (onlyWarnOnLoop && !ControlFlowUtils.isInLoop(assignment)) {
|
||||
return;
|
||||
|
||||
+2
-4
@@ -57,8 +57,7 @@ class ArrayContentsAssignedVisitor extends JavaRecursiveElementVisitor {
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken operationSign = expression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS))){
|
||||
return;
|
||||
@@ -84,8 +83,7 @@ class ArrayContentsAssignedVisitor extends JavaRecursiveElementVisitor {
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(expression);
|
||||
final PsiJavaToken operationSign = expression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS))){
|
||||
return;
|
||||
|
||||
@@ -29,8 +29,7 @@ public class BoolUtils {
|
||||
return false;
|
||||
}
|
||||
final PsiPrefixExpression prefixExp = (PsiPrefixExpression) expression;
|
||||
final PsiJavaToken sign = prefixExp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExp.getOperationTokenType();
|
||||
return JavaTokenType.EXCL.equals(tokenType);
|
||||
}
|
||||
|
||||
@@ -61,9 +60,8 @@ public class BoolUtils {
|
||||
} else if (ComparisonUtils.isComparison(condition)) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if (rhs == null) {
|
||||
|
||||
@@ -18,7 +18,6 @@ package com.siyeh.ig.psiutils;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.PsiBinaryExpression;
|
||||
import com.intellij.psi.PsiExpression;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
@@ -74,8 +73,7 @@ public class ComparisonUtils {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
return isComparisonOperation(tokenType);
|
||||
}
|
||||
|
||||
@@ -83,9 +81,8 @@ public class ComparisonUtils {
|
||||
return s_comparisonTokens.contains(tokenType);
|
||||
}
|
||||
|
||||
public static String getFlippedComparison(@NotNull PsiJavaToken token) {
|
||||
final IElementType tokenType = token.getTokenType();
|
||||
return s_swappedComparisons.get(tokenType);
|
||||
public static String getFlippedComparison(IElementType tokenType) {
|
||||
return s_swappedComparisons.get(tokenType);
|
||||
}
|
||||
|
||||
public static boolean isEqualityComparison(
|
||||
@@ -95,8 +92,7 @@ public class ComparisonUtils {
|
||||
tokenType.equals(JavaTokenType.NE);
|
||||
}
|
||||
|
||||
public static String getNegatedComparison(@NotNull PsiJavaToken token) {
|
||||
final IElementType tokenType = token.getTokenType();
|
||||
return s_invertedComparisons.get(tokenType);
|
||||
}
|
||||
public static String getNegatedComparison(IElementType tokenType) {
|
||||
return s_invertedComparisons.get(tokenType);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -879,10 +879,8 @@ public class EquivalenceChecker{
|
||||
private static boolean prefixExpressionsAreEquivalent(
|
||||
@NotNull PsiPrefixExpression prefixExp1,
|
||||
@NotNull PsiPrefixExpression prefixExp2){
|
||||
final PsiJavaToken sign1 = prefixExp1.getOperationSign();
|
||||
final PsiJavaToken sign2 = prefixExp2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = prefixExp1.getOperationTokenType();
|
||||
if(!tokenType1.equals(prefixExp2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression operand1 = prefixExp1.getOperand();
|
||||
@@ -893,10 +891,8 @@ public class EquivalenceChecker{
|
||||
private static boolean postfixExpressionsAreEquivalent(
|
||||
@NotNull PsiPostfixExpression postfixExp1,
|
||||
@NotNull PsiPostfixExpression postfixExp2){
|
||||
final PsiJavaToken sign1 = postfixExp1.getOperationSign();
|
||||
final PsiJavaToken sign2 = postfixExp2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = postfixExp1.getOperationTokenType();
|
||||
if(!tokenType1.equals(postfixExp2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression operand1 = postfixExp1.getOperand();
|
||||
@@ -907,10 +903,8 @@ public class EquivalenceChecker{
|
||||
private static boolean binaryExpressionsAreEquivalent(
|
||||
@NotNull PsiBinaryExpression binaryExp1,
|
||||
@NotNull PsiBinaryExpression binaryExp2){
|
||||
final PsiJavaToken sign1 = binaryExp1.getOperationSign();
|
||||
final PsiJavaToken sign2 = binaryExp2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = binaryExp1.getOperationTokenType();
|
||||
if(!tokenType1.equals(binaryExp2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression lhs1 = binaryExp1.getLOperand();
|
||||
@@ -924,10 +918,8 @@ public class EquivalenceChecker{
|
||||
private static boolean assignmentExpressionsAreEquivalent(
|
||||
@NotNull PsiAssignmentExpression assignExp1,
|
||||
@NotNull PsiAssignmentExpression assignExp2){
|
||||
final PsiJavaToken sign1 = assignExp1.getOperationSign();
|
||||
final PsiJavaToken sign2 = assignExp2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = assignExp1.getOperationTokenType();
|
||||
if(!tokenType1.equals(assignExp2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression lhs1 = assignExp1.getLExpression();
|
||||
|
||||
@@ -157,8 +157,7 @@ public class ExpectedTypeUtils{
|
||||
|
||||
@Override public void visitBinaryExpression(
|
||||
@NotNull PsiBinaryExpression binaryExpression) {
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
final PsiType type = binaryExpression.getType();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if (rhs == null) {
|
||||
@@ -295,9 +294,7 @@ public class ExpectedTypeUtils{
|
||||
@Override public void visitAssignmentExpression(
|
||||
@NotNull PsiAssignmentExpression assignment){
|
||||
final PsiExpression rExpression = assignment.getRExpression();
|
||||
final PsiJavaToken operationSign =
|
||||
assignment.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = assignment.getOperationTokenType();
|
||||
final PsiExpression lExpression =
|
||||
assignment.getLExpression();
|
||||
final PsiType lType = lExpression.getType();
|
||||
|
||||
@@ -243,19 +243,17 @@ public class ExpressionUtils {
|
||||
if (condition instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)condition;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
return tokenType.equals(JavaTokenType.EXCL);
|
||||
} else if (condition instanceof PsiBinaryExpression) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if (rhs == null) {
|
||||
return false;
|
||||
}
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.NE)) {
|
||||
if (ignoreNegatedNullComparison) {
|
||||
final String lhsText = lhs.getText();
|
||||
@@ -307,8 +305,7 @@ public class ExpressionUtils {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)strippedExpression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (!JavaTokenType.PLUS.equals(tokenType) &&
|
||||
!JavaTokenType.MINUS.equals(tokenType)) {
|
||||
return false;
|
||||
@@ -331,8 +328,7 @@ public class ExpressionUtils {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.LT) ||
|
||||
tokenType.equals(JavaTokenType.LE)) {
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
@@ -354,8 +350,7 @@ public class ExpressionUtils {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.GT) ||
|
||||
tokenType.equals(JavaTokenType.GE)) {
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
|
||||
@@ -109,9 +109,7 @@ public class InstanceOfUtils {
|
||||
|
||||
@Override public void visitBinaryExpression(
|
||||
PsiBinaryExpression expression) {
|
||||
final PsiJavaToken sign =
|
||||
expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (tokenType == JavaTokenType.ANDAND) {
|
||||
checkExpression(expression.getLOperand());
|
||||
if (agreeingInstanceof) {
|
||||
|
||||
@@ -298,8 +298,7 @@ public class RecursionUtils{
|
||||
if(expressionDefinitelyRecurses(lhs, method)){
|
||||
return true;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.ANDAND) ||
|
||||
tokenType.equals(JavaTokenType.OROR)){
|
||||
return false;
|
||||
|
||||
@@ -73,8 +73,7 @@ public class SideEffectChecker{
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
mayHaveSideEffects = true;
|
||||
@@ -87,8 +86,7 @@ public class SideEffectChecker{
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
mayHaveSideEffects = true;
|
||||
|
||||
@@ -101,8 +101,7 @@ public class SwitchUtils{
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType operation = sign.getTokenType();
|
||||
final IElementType operation = binaryExpression.getOperationTokenType();
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if(operation.equals(JavaTokenType.OROR)){
|
||||
@@ -143,8 +142,7 @@ public class SwitchUtils{
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType operation = sign.getTokenType();
|
||||
final IElementType operation = binaryExpression.getOperationTokenType();
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if(operation.equals(JavaTokenType.OROR)){
|
||||
|
||||
@@ -263,8 +263,7 @@ public class VariableAccessUtils{
|
||||
if (expression instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return false;
|
||||
}
|
||||
@@ -273,8 +272,7 @@ public class VariableAccessUtils{
|
||||
} else if (expression instanceof PsiPostfixExpression) {
|
||||
final PsiPostfixExpression postfixExpression =
|
||||
(PsiPostfixExpression)expression;
|
||||
final PsiJavaToken sign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return false;
|
||||
}
|
||||
@@ -334,8 +332,7 @@ public class VariableAccessUtils{
|
||||
if (expression instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS)) {
|
||||
return false;
|
||||
}
|
||||
@@ -344,8 +341,7 @@ public class VariableAccessUtils{
|
||||
} else if (expression instanceof PsiPostfixExpression) {
|
||||
final PsiPostfixExpression postfixExpression =
|
||||
(PsiPostfixExpression)expression;
|
||||
final PsiJavaToken sign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -74,8 +74,7 @@ class VariableAssignedVisitor extends JavaRecursiveElementVisitor{
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(prefixExpression);
|
||||
final PsiJavaToken operationSign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
@@ -95,8 +94,7 @@ class VariableAssignedVisitor extends JavaRecursiveElementVisitor{
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(postfixExpression);
|
||||
final PsiJavaToken operationSign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
|
||||
@@ -72,9 +72,7 @@ class VariableValueUsedVisitor extends JavaRecursiveElementVisitor {
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(prefixExpression);
|
||||
final PsiJavaToken operationSign =
|
||||
prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
@@ -99,9 +97,7 @@ class VariableValueUsedVisitor extends JavaRecursiveElementVisitor {
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(postfixExpression);
|
||||
final PsiJavaToken operationSign =
|
||||
postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return;
|
||||
|
||||
@@ -18,7 +18,6 @@ package com.siyeh.ig.style;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.PsiBinaryExpression;
|
||||
import com.intellij.psi.PsiExpression;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.siyeh.InspectionGadgetsBundle;
|
||||
import com.siyeh.ig.BaseInspection;
|
||||
@@ -71,8 +70,7 @@ public class ChainedEqualityInspection extends BaseInspection {
|
||||
|
||||
private static boolean isEqualityComparison(
|
||||
@NotNull PsiBinaryExpression expression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
return tokenType.equals(JavaTokenType.EQEQ) ||
|
||||
tokenType.equals(JavaTokenType.NE);
|
||||
}
|
||||
|
||||
+2
-4
@@ -19,7 +19,6 @@ import com.intellij.codeInspection.ProblemDescriptor;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.psi.PsiBinaryExpression;
|
||||
import com.intellij.psi.PsiExpression;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.util.PsiUtil;
|
||||
import com.intellij.util.IncorrectOperationException;
|
||||
import com.siyeh.InspectionGadgetsBundle;
|
||||
@@ -78,9 +77,8 @@ public class ConstantOnLHSOfComparisonInspection extends BaseInspection {
|
||||
if (rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String flippedComparison =
|
||||
ComparisonUtils.getFlippedComparison(sign);
|
||||
final String flippedComparison =
|
||||
ComparisonUtils.getFlippedComparison(expression.getOperationTokenType());
|
||||
if (flippedComparison == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
+2
-4
@@ -19,7 +19,6 @@ import com.intellij.codeInspection.ProblemDescriptor;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.psi.PsiBinaryExpression;
|
||||
import com.intellij.psi.PsiExpression;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.util.PsiUtil;
|
||||
import com.intellij.util.IncorrectOperationException;
|
||||
import com.siyeh.InspectionGadgetsBundle;
|
||||
@@ -78,9 +77,8 @@ public class ConstantOnRHSOfComparisonInspection extends BaseInspection {
|
||||
if (rhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String flippedComparison =
|
||||
ComparisonUtils.getFlippedComparison(sign);
|
||||
final String flippedComparison =
|
||||
ComparisonUtils.getFlippedComparison(expression.getOperationTokenType());
|
||||
if (flippedComparison == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
+14
-21
@@ -47,17 +47,16 @@ public class ListIndexOfReplaceableByContainsInspection
|
||||
public String buildErrorString(Object... infos) {
|
||||
final PsiBinaryExpression expression = (PsiBinaryExpression)infos[0];
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String text;
|
||||
final String text;
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
text = createContainsExpressionText(callExpression, sign, false);
|
||||
text = createContainsExpressionText(callExpression, false, expression.getOperationTokenType());
|
||||
} else {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)expression.getROperand();
|
||||
assert callExpression != null;
|
||||
text = createContainsExpressionText(callExpression, sign, true);
|
||||
text = createContainsExpressionText(callExpression, true, expression.getOperationTokenType());
|
||||
}
|
||||
return InspectionGadgetsBundle.message(
|
||||
"indexof.replaceable.by.contains.problem.descriptor", text);
|
||||
@@ -79,20 +78,19 @@ public class ListIndexOfReplaceableByContainsInspection
|
||||
(PsiBinaryExpression)descriptor.getPsiElement();
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiExpression rhs = expression.getROperand();
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String newExpressionText;
|
||||
final String newExpressionText;
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
newExpressionText =
|
||||
createContainsExpressionText(callExpression, sign,
|
||||
false);
|
||||
createContainsExpressionText(callExpression,
|
||||
false, expression.getOperationTokenType());
|
||||
} else {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)rhs;
|
||||
assert callExpression != null;
|
||||
newExpressionText =
|
||||
createContainsExpressionText(callExpression, sign, true);
|
||||
createContainsExpressionText(callExpression, true, expression.getOperationTokenType());
|
||||
}
|
||||
replaceExpression(expression, newExpressionText);
|
||||
}
|
||||
@@ -105,10 +103,8 @@ public class ListIndexOfReplaceableByContainsInspection
|
||||
}
|
||||
|
||||
static String createContainsExpressionText(
|
||||
@NotNull PsiMethodCallExpression call,
|
||||
@NotNull PsiJavaToken sign,
|
||||
boolean flipped) {
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
@NotNull PsiMethodCallExpression call,
|
||||
boolean flipped, IElementType tokenType) {
|
||||
final PsiReferenceExpression methodExpression =
|
||||
call.getMethodExpression();
|
||||
final PsiExpression qualifierExpression =
|
||||
@@ -154,21 +150,19 @@ public class ListIndexOfReplaceableByContainsInspection
|
||||
}
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
if (lhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByContains(lhs, sign, rhs, false)) {
|
||||
if (canBeReplacedByContains(lhs, rhs, false, expression.getOperationTokenType())) {
|
||||
registerError(expression, expression);
|
||||
}
|
||||
} else if (rhs instanceof PsiMethodCallExpression) {
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
if (canBeReplacedByContains(rhs, sign, lhs, true)) {
|
||||
if (canBeReplacedByContains(rhs, lhs, true, expression.getOperationTokenType())) {
|
||||
registerError(expression, expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean canBeReplacedByContains(
|
||||
PsiExpression lhs, PsiJavaToken sign,
|
||||
PsiExpression rhs, boolean flipped) {
|
||||
PsiExpression lhs,
|
||||
PsiExpression rhs, boolean flipped, IElementType tokenType) {
|
||||
final PsiMethodCallExpression callExpression =
|
||||
(PsiMethodCallExpression)lhs;
|
||||
if (!isIndexOfCall(callExpression)) {
|
||||
@@ -181,8 +175,7 @@ public class ListIndexOfReplaceableByContainsInspection
|
||||
}
|
||||
final Integer integer = (Integer)object;
|
||||
final int constant = integer.intValue();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
if (flipped) {
|
||||
if (flipped) {
|
||||
if (constant == -1 && (JavaTokenType.NE.equals(tokenType) ||
|
||||
JavaTokenType.LT.equals(tokenType) ||
|
||||
JavaTokenType.EQEQ.equals(tokenType) ||
|
||||
|
||||
@@ -91,9 +91,8 @@ public abstract class Intention extends PsiElementBaseIntentionAction {
|
||||
} else if(ComparisonUtils.isComparison(newExpression)){
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) newExpression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
assert rhs != null;
|
||||
|
||||
+1
-2
@@ -28,8 +28,7 @@ class BooleanLiteralEqualityPredicate implements PsiElementPredicate{
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression expression = (PsiBinaryExpression) element;
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.EQEQ) &&
|
||||
!tokenType.equals(JavaTokenType.NE)){
|
||||
return false;
|
||||
|
||||
@@ -18,7 +18,6 @@ package com.siyeh.ipp.bool;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.PsiBinaryExpression;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.siyeh.ipp.base.PsiElementPredicate;
|
||||
import com.siyeh.ipp.psiutils.ErrorUtil;
|
||||
@@ -30,8 +29,7 @@ class ConjunctionPredicate implements PsiElementPredicate{
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression expression = (PsiBinaryExpression) element;
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.ANDAND) &&
|
||||
!tokenType.equals(JavaTokenType.OROR)) {
|
||||
return false;
|
||||
|
||||
@@ -31,8 +31,7 @@ public class DemorgansIntention extends MutablyNamedIntention {
|
||||
protected String getTextForElement(PsiElement element) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)element;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (tokenType.equals(JavaTokenType.ANDAND)) {
|
||||
return IntentionPowerPackBundle.message("demorgans.intention.name1");
|
||||
} else {
|
||||
@@ -49,8 +48,7 @@ public class DemorgansIntention extends MutablyNamedIntention {
|
||||
throws IncorrectOperationException {
|
||||
PsiBinaryExpression exp =
|
||||
(PsiBinaryExpression)element;
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
PsiElement parent = exp.getParent();
|
||||
while (isConjunctionExpression(parent, tokenType)) {
|
||||
exp = (PsiBinaryExpression)parent;
|
||||
@@ -106,9 +104,8 @@ public class DemorgansIntention extends MutablyNamedIntention {
|
||||
} else if (ComparisonUtils.isComparison(condition)) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
assert rhs != null;
|
||||
@@ -127,8 +124,7 @@ public class DemorgansIntention extends MutablyNamedIntention {
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression binExp = (PsiBinaryExpression)exp;
|
||||
final PsiJavaToken sign = binExp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binExp.getOperationTokenType();
|
||||
return tokenType.equals(conjunctionType);
|
||||
}
|
||||
}
|
||||
@@ -43,8 +43,7 @@ public class FlipConjunctionIntention extends MutablyNamedIntention {
|
||||
PsiExpression exp = (PsiExpression)element;
|
||||
final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)exp;
|
||||
assert binaryExpression != null;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType conjunctionType = sign.getTokenType();
|
||||
final IElementType conjunctionType = binaryExpression.getOperationTokenType();
|
||||
PsiElement parent = exp.getParent();
|
||||
while (isConjunctionExpression(parent, conjunctionType)) {
|
||||
exp = (PsiExpression)parent;
|
||||
@@ -83,8 +82,7 @@ public class FlipConjunctionIntention extends MutablyNamedIntention {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)element;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
return tokenType.equals(conjunctionType);
|
||||
}
|
||||
}
|
||||
@@ -36,7 +36,7 @@ public class NegateComparisonIntention extends MutablyNamedIntention {
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
operatorText = sign.getText();
|
||||
negatedOperatorText =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
ComparisonUtils.getNegatedComparison(sign.getTokenType());
|
||||
}
|
||||
if (operatorText.equals(negatedOperatorText)) {
|
||||
return IntentionPowerPackBundle.message(
|
||||
@@ -59,9 +59,8 @@ public class NegateComparisonIntention extends MutablyNamedIntention {
|
||||
(PsiBinaryExpression)element;
|
||||
final PsiExpression lhs = expression.getLOperand();
|
||||
final PsiExpression rhs = expression.getROperand();
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final String negatedOperator =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedOperator =
|
||||
ComparisonUtils.getNegatedComparison(expression.getOperationTokenType());
|
||||
final String lhsText = lhs.getText();
|
||||
assert rhs != null;
|
||||
final String rhsText = rhs.getText();
|
||||
|
||||
+1
-2
@@ -44,8 +44,7 @@ public class RemoveBooleanEqualityIntention extends MutablyNamedIntention {
|
||||
final PsiBinaryExpression exp =
|
||||
(PsiBinaryExpression)element;
|
||||
assert exp != null;
|
||||
final PsiJavaToken sign = exp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
final boolean isEquals = JavaTokenType.EQEQ.equals(tokenType);
|
||||
final PsiExpression lhs = exp.getLOperand();
|
||||
@NonNls final String lhsText = lhs.getText();
|
||||
|
||||
@@ -59,8 +59,7 @@ class CharToStringPredicate implements PsiElementPredicate{
|
||||
} else if(parent instanceof PsiAssignmentExpression){
|
||||
final PsiAssignmentExpression parentExpression =
|
||||
(PsiAssignmentExpression) parent;
|
||||
final PsiJavaToken sign = parentExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = parentExpression.getOperationTokenType();
|
||||
if(!JavaTokenType.PLUSEQ.equals(tokenType)){
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -77,8 +77,7 @@ class StringToCharPredicate implements PsiElementPredicate{
|
||||
} else if(parent instanceof PsiAssignmentExpression){
|
||||
final PsiAssignmentExpression parentExpression =
|
||||
(PsiAssignmentExpression) parent;
|
||||
final PsiJavaToken sign = parentExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = parentExpression.getOperationTokenType();
|
||||
if(!JavaTokenType.PLUSEQ.equals(tokenType)){
|
||||
return false;
|
||||
}
|
||||
|
||||
+1
-2
@@ -39,8 +39,7 @@ class StringConcatPredicate implements PsiElementPredicate{
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) parent;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUS)){
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -28,8 +28,7 @@ class ObjectEqualityPredicate implements PsiElementPredicate{
|
||||
return false;
|
||||
}
|
||||
final PsiBinaryExpression expression = (PsiBinaryExpression) element;
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.NE) &&
|
||||
!tokenType.equals(JavaTokenType.EQEQ)){
|
||||
return false;
|
||||
|
||||
+1
-2
@@ -50,8 +50,7 @@ public class ReplaceEqualityWithEqualsIntention extends Intention {
|
||||
if (strippedRhs == null) {
|
||||
return;
|
||||
}
|
||||
final PsiJavaToken operationSign = exp.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = exp.getOperationTokenType();
|
||||
@NonNls final String expString;
|
||||
if (tokenType.equals(JavaTokenType.EQEQ)) {
|
||||
if (ParenthesesUtils.getPrecedence(strippedLhs) >
|
||||
|
||||
@@ -162,8 +162,7 @@ public class CreateAssertIntention extends Intention {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
return JavaTokenType.EQEQ.equals(tokenType);
|
||||
}
|
||||
|
||||
@@ -173,8 +172,7 @@ public class CreateAssertIntention extends Intention {
|
||||
}
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = binaryExpression.getOperationTokenType();
|
||||
if (!JavaTokenType.EQEQ.equals(tokenType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
+2
-4
@@ -32,8 +32,7 @@ class AssignmentExpressionReplaceableWithOperatorAssigment
|
||||
}
|
||||
final PsiAssignmentExpression assignment =
|
||||
(PsiAssignmentExpression) element;
|
||||
final PsiJavaToken sign = assignment.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = assignment.getOperationTokenType();
|
||||
if(!JavaTokenType.EQ.equals(tokenType)){
|
||||
return false;
|
||||
}
|
||||
@@ -51,8 +50,7 @@ class AssignmentExpressionReplaceableWithOperatorAssigment
|
||||
if(rhsRhs == null){
|
||||
return false;
|
||||
}
|
||||
final PsiJavaToken operatorSign = binaryRhs.getOperationSign();
|
||||
final IElementType rhsTokenType = operatorSign.getTokenType();
|
||||
final IElementType rhsTokenType = binaryRhs.getOperationTokenType();
|
||||
if(JavaTokenType.OROR.equals(rhsTokenType) ||
|
||||
JavaTokenType.ANDAND.equals(rhsTokenType) ||
|
||||
JavaTokenType.EQEQ.equals(rhsTokenType) ||
|
||||
|
||||
+2
-3
@@ -82,9 +82,8 @@ public class ReplaceOperatorAssignmentWithAssignmentIntention
|
||||
if (rhs instanceof PsiBinaryExpression) {
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)rhs;
|
||||
final PsiJavaToken javaToken = binaryExpression.getOperationSign();
|
||||
final int precedence1 =
|
||||
ParenthesesUtils.getPrecedenceForBinaryOperator(javaToken);
|
||||
final int precedence1 =
|
||||
ParenthesesUtils.getPrecedenceForBinaryOperator(binaryExpression.getOperationTokenType());
|
||||
final IElementType signTokenType = sign.getTokenType();
|
||||
final IElementType newOperatorToken = tokenMap.get(signTokenType);
|
||||
final int precedence2 =
|
||||
|
||||
+1
-3
@@ -53,9 +53,7 @@ class UnnecessaryParenthesesPredicate implements PsiElementPredicate{
|
||||
final PsiJavaToken parentSign =
|
||||
binaryExpression.getOperationSign();
|
||||
final IElementType parentOperator = parentSign.getTokenType();
|
||||
final PsiJavaToken childSign =
|
||||
((PsiBinaryExpression) body).getOperationSign();
|
||||
final IElementType childOperator = childSign.getTokenType();
|
||||
final IElementType childOperator = ((PsiBinaryExpression)body).getOperationTokenType();
|
||||
if(!parentOperator.equals(childOperator)){
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -32,8 +32,7 @@ public class BoolUtils{
|
||||
if(ancestor.getParent() instanceof PsiPrefixExpression){
|
||||
final PsiPrefixExpression prefixAncestor =
|
||||
(PsiPrefixExpression) ancestor.getParent();
|
||||
final PsiJavaToken sign = prefixAncestor.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixAncestor.getOperationTokenType();
|
||||
if(tokenType.equals(JavaTokenType.EXCL)){
|
||||
return true;
|
||||
}
|
||||
@@ -50,8 +49,7 @@ public class BoolUtils{
|
||||
if(ancestor.getParent() instanceof PsiPrefixExpression){
|
||||
final PsiPrefixExpression prefixAncestor =
|
||||
(PsiPrefixExpression) ancestor.getParent();
|
||||
final PsiJavaToken sign = prefixAncestor.getOperationSign();
|
||||
if(JavaTokenType.EXCL.equals(sign.getTokenType())){
|
||||
if(JavaTokenType.EXCL.equals(prefixAncestor.getOperationTokenType())){
|
||||
return prefixAncestor;
|
||||
}
|
||||
}
|
||||
@@ -63,8 +61,7 @@ public class BoolUtils{
|
||||
return false;
|
||||
}
|
||||
final PsiPrefixExpression prefixExp = (PsiPrefixExpression) exp;
|
||||
final PsiJavaToken sign = prefixExp.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExp.getOperationTokenType();
|
||||
return tokenType.equals(JavaTokenType.EXCL);
|
||||
}
|
||||
|
||||
@@ -109,9 +106,8 @@ public class BoolUtils{
|
||||
} else if(ComparisonUtils.isComparison(condition)){
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression) condition;
|
||||
final PsiJavaToken sign = binaryExpression.getOperationSign();
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(sign);
|
||||
final String negatedComparison =
|
||||
ComparisonUtils.getNegatedComparison(binaryExpression.getOperationTokenType());
|
||||
final PsiExpression lhs = binaryExpression.getLOperand();
|
||||
final PsiExpression rhs = binaryExpression.getROperand();
|
||||
if(rhs == null){
|
||||
|
||||
@@ -86,11 +86,6 @@ public class ComparisonUtils{
|
||||
return flippedComparisons.get(text);
|
||||
}
|
||||
|
||||
public static String getNegatedComparison(@NotNull PsiJavaToken sign){
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
return getNegatedComparison(tokenType);
|
||||
}
|
||||
|
||||
public static String getNegatedComparison(IElementType tokenType){
|
||||
return negatedComparisons.get(tokenType);
|
||||
}
|
||||
|
||||
@@ -794,10 +794,8 @@ public class EquivalenceChecker{
|
||||
private static boolean prefixExpressionsAreEquivalent(
|
||||
@NotNull PsiPrefixExpression prefixExpression1,
|
||||
@NotNull PsiPrefixExpression prefixExpression2){
|
||||
final PsiJavaToken sign1 = prefixExpression1.getOperationSign();
|
||||
final PsiJavaToken sign2 = prefixExpression2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = prefixExpression1.getOperationTokenType();
|
||||
if(!tokenType1.equals(prefixExpression2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression operand1 = prefixExpression1.getOperand();
|
||||
@@ -808,10 +806,8 @@ public class EquivalenceChecker{
|
||||
private static boolean postfixExpressionsAreEquivalent(
|
||||
@NotNull PsiPostfixExpression postfixExpression1,
|
||||
@NotNull PsiPostfixExpression postfixExpression2){
|
||||
final PsiJavaToken sign1 = postfixExpression1.getOperationSign();
|
||||
final PsiJavaToken sign2 = postfixExpression2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = postfixExpression1.getOperationTokenType();
|
||||
if(!tokenType1.equals(postfixExpression2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression operand1 = postfixExpression1.getOperand();
|
||||
@@ -822,10 +818,8 @@ public class EquivalenceChecker{
|
||||
private static boolean binaryExpressionsAreEquivalent(
|
||||
@NotNull PsiBinaryExpression binaryExpression1,
|
||||
@NotNull PsiBinaryExpression binaryExpression2){
|
||||
final PsiJavaToken sign1 = binaryExpression1.getOperationSign();
|
||||
final PsiJavaToken sign2 = binaryExpression2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = binaryExpression1.getOperationTokenType();
|
||||
if(!tokenType1.equals(binaryExpression2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression lhs1 = binaryExpression1.getLOperand();
|
||||
@@ -839,10 +833,8 @@ public class EquivalenceChecker{
|
||||
private static boolean assignmentExpressionsAreEquivalent(
|
||||
@NotNull PsiAssignmentExpression assignmentExpression1,
|
||||
@NotNull PsiAssignmentExpression assignmentExpression2){
|
||||
final PsiJavaToken sign1 = assignmentExpression1.getOperationSign();
|
||||
final PsiJavaToken sign2 = assignmentExpression2.getOperationSign();
|
||||
final IElementType tokenType1 = sign1.getTokenType();
|
||||
if(!tokenType1.equals(sign2.getTokenType())){
|
||||
final IElementType tokenType1 = assignmentExpression1.getOperationTokenType();
|
||||
if(!tokenType1.equals(assignmentExpression2.getOperationTokenType())){
|
||||
return false;
|
||||
}
|
||||
final PsiExpression lhs1 = assignmentExpression1.getLExpression();
|
||||
|
||||
@@ -129,9 +129,7 @@ public class ParenthesesUtils{
|
||||
if(expression instanceof PsiBinaryExpression){
|
||||
final PsiBinaryExpression binaryExpression =
|
||||
(PsiBinaryExpression)expression;
|
||||
final PsiJavaToken sign =
|
||||
binaryExpression.getOperationSign();
|
||||
return getPrecedenceForBinaryOperator(sign);
|
||||
return getPrecedenceForBinaryOperator(binaryExpression.getOperationTokenType());
|
||||
}
|
||||
if(expression instanceof PsiInstanceOfExpression){
|
||||
return RELATIONAL_PRECEDENCE;
|
||||
@@ -148,11 +146,6 @@ public class ParenthesesUtils{
|
||||
return -1;
|
||||
}
|
||||
|
||||
public static int getPrecedenceForBinaryOperator(@NotNull PsiJavaToken sign){
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
return getPrecedenceForBinaryOperator(tokenType);
|
||||
}
|
||||
|
||||
public static int getPrecedenceForBinaryOperator(IElementType operator) {
|
||||
final Integer precedence = s_binaryOperatorPrecedence.get(operator);
|
||||
return precedence.intValue();
|
||||
|
||||
@@ -56,8 +56,7 @@ public class SideEffectChecker{
|
||||
|
||||
@Override public void visitPrefixExpression(PsiPrefixExpression expression){
|
||||
super.visitPrefixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
@@ -67,8 +66,7 @@ public class SideEffectChecker{
|
||||
|
||||
@Override public void visitPostfixExpression(PsiPostfixExpression expression){
|
||||
super.visitPostfixExpression(expression);
|
||||
final PsiJavaToken sign = expression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = expression.getOperationTokenType();
|
||||
|
||||
if(tokenType.equals(JavaTokenType.PLUSPLUS) ||
|
||||
tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
|
||||
@@ -66,8 +66,7 @@ public class VariableAccessUtils {
|
||||
if (expression instanceof PsiPrefixExpression) {
|
||||
final PsiPrefixExpression prefixExpression =
|
||||
(PsiPrefixExpression)expression;
|
||||
final PsiJavaToken sign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return false;
|
||||
@@ -77,8 +76,7 @@ public class VariableAccessUtils {
|
||||
} else if (expression instanceof PsiPostfixExpression) {
|
||||
final PsiPostfixExpression postfixExpression =
|
||||
(PsiPostfixExpression)expression;
|
||||
final PsiJavaToken sign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = sign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if (!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)) {
|
||||
return false;
|
||||
|
||||
@@ -72,8 +72,7 @@ class VariableAssignedVisitor extends JavaRecursiveElementVisitor{
|
||||
return;
|
||||
}
|
||||
super.visitPrefixExpression(prefixExpression);
|
||||
final PsiJavaToken operationSign = prefixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = prefixExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
@@ -92,8 +91,7 @@ class VariableAssignedVisitor extends JavaRecursiveElementVisitor{
|
||||
return;
|
||||
}
|
||||
super.visitPostfixExpression(postfixExpression);
|
||||
final PsiJavaToken operationSign = postfixExpression.getOperationSign();
|
||||
final IElementType tokenType = operationSign.getTokenType();
|
||||
final IElementType tokenType = postfixExpression.getOperationTokenType();
|
||||
if(!tokenType.equals(JavaTokenType.PLUSPLUS) &&
|
||||
!tokenType.equals(JavaTokenType.MINUSMINUS)){
|
||||
return;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user