From bba33f1c174e1dc0da125f50771a44b024566e0c Mon Sep 17 00:00:00 2001 From: Michal Fudala Date: Thu, 6 Jul 2017 12:19:54 +0200 Subject: [PATCH 1/2] add better support for compareTo folding (>= and <=) --- .../AdvancedExpressionFoldingBuilder.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java b/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java index 92f67d02..b28aa089 100644 --- a/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java +++ b/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java @@ -864,6 +864,20 @@ private static Expression getBinaryExpression(@NotNull PsiBinaryExpression eleme case "0": return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); } + case "<=": + switch (literalExpression.getText()) { + case "-1": + return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case "0": + return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + case ">=": + switch (literalExpression.getText()) { + case "1": + return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case "0": + return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } } } } From 1292aa61d857bf65f395f1f46d14aae02f7217e3 Mon Sep 17 00:00:00 2001 From: Michal Fudala Date: Fri, 7 Jul 2017 18:53:19 +0200 Subject: [PATCH 2/2] fix bug for compareTo when literal expression (0, -1 or 1) is on the left side --- .../AdvancedExpressionFoldingBuilder.java | 111 ++++++++++-------- 1 file changed, 64 insertions(+), 47 deletions(-) diff --git a/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java b/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java index b28aa089..1a3bf398 100644 --- a/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java +++ b/src/com/intellij/advancedExpressionFolding/AdvancedExpressionFoldingBuilder.java @@ -814,9 +814,11 @@ private static Expression getBinaryExpression(@NotNull PsiBinaryExpression eleme @Nullable PsiLiteralExpression literalExpression = (PsiLiteralExpression) (element .getLOperand() instanceof PsiLiteralExpression ? element.getLOperand() : element.getROperand()); + if (literalExpression != null && literalExpression.getText().equals("0") || literalExpression != null && literalExpression.getText().equals("-1") || literalExpression != null && literalExpression.getText().equals("1")) { + @NotNull Optional identifier = Stream.of(methodCallExpression.getMethodExpression().getChildren()) .filter(c -> c instanceof PsiIdentifier).findAny(); if (identifier.isPresent() && identifier.get().getText().equals("compareTo") && methodCallExpression.getArgumentList().getExpressions().length == 1) { @@ -831,53 +833,68 @@ private static Expression getBinaryExpression(@NotNull PsiBinaryExpression eleme if (qualifier != null) { @NotNull Expression argument = getAnyExpression(methodCallExpression.getArgumentList() .getExpressions()[0], document); - switch (element.getOperationSign().getText()) { - case "==": - switch (literalExpression.getText()) { - case "-1": - return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new Equal(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "1": - return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } - case "!=": - switch (literalExpression.getText()) { - case "1": - return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new NotEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "-1": - return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } - case "<": - switch (literalExpression.getText()) { - case "1": - return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } - case ">": - switch (literalExpression.getText()) { - case "-1": - return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } - case "<=": - switch (literalExpression.getText()) { - case "-1": - return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } - case ">=": - switch (literalExpression.getText()) { - case "1": - return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - case "0": - return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); - } + + String operationSign = element.getOperationSign().getText(); + + int expression = Integer.parseInt(literalExpression.getText()); + String lessOperation = "<"; + String greaterOperation = ">"; + if (literalExpression == element.getLOperand()) { + lessOperation = ">"; + greaterOperation = "<"; + } + + if (operationSign.equals("==")) { + switch (expression) { + case -1: + return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new Equal(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 1: + return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + } else if (operationSign.equals("!=")) { + switch (expression) { + case 1: + return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new NotEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case -1: + return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + + } + else if(operationSign.equals(lessOperation)) { + switch (expression) { + case 1: + return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + } + else if(operationSign.equals(greaterOperation)) { + switch (expression) { + case -1: + return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + } + else if(operationSign.equals(lessOperation + "=")) { + switch (expression) { + case -1: + return new Less(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new LessEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } + } + else if(operationSign.equals(greaterOperation + "=")) { + switch (expression) { + case 1: + return new Greater(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + case 0: + return new GreaterEqual(element, element.getTextRange(), Arrays.asList(qualifier, argument)); + } } } }