Improved JoinAssertThatStatements detection of expressions with side-effects and added pre/post-increment/decrement detection.

src/main/java/de/platon42/intellij/plugins/cajon/inspections/JoinAssertThatStatementsInspection.kt

@@ -35,16 +35,9 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                         reset = (lastActualExpression == null)
                         actualExpression = assertThatCall.firstArg
                         if (!reset) {
-                            val isSame = when (actualExpression) {
-                                is PsiMethodCallExpression -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                                        // Note: replace with PsiTreeUtil.findChildrenOfAnyType(strict = false) for IDEA >= 2018.1
-                                        && !KNOWN_METHODS_WITH_SIDE_EFFECTS.test(actualExpression)
-                                        && PsiTreeUtil.findChildrenOfAnyType(
-                                    actualExpression,
-                                    PsiMethodCallExpression::class.java
-                                ).none { KNOWN_METHODS_WITH_SIDE_EFFECTS.test(it) }
-                                else -> equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
-                            }
+                            val isSame = equivalenceChecker.expressionsAreEquivalent(actualExpression, lastActualExpression)
+                                    && !hasExpressionWithSideEffects(actualExpression)
+
                             if (isSame) {
                                 sameCount++
                                 lastStatement = statement
@@ -78,6 +71,25 @@ class JoinAssertThatStatementsInspection : AbstractAssertJInspection() {
                 }
                 return null
             }
+
+            private fun hasExpressionWithSideEffects(actualExpression: PsiExpression): Boolean {
+                var result = false
+                PsiTreeUtil.processElements(actualExpression) { element ->
+                    val matched = when (element) {
+                        is PsiUnaryExpression -> (element.operationTokenType == JavaTokenType.PLUSPLUS)
+                                || (element.operationTokenType == JavaTokenType.MINUSMINUS)
+                        is PsiMethodCallExpression -> KNOWN_METHODS_WITH_SIDE_EFFECTS.test(element)
+                        else -> false
+                    }
+                    if (matched) {
+                        result = true
+                        false
+                    } else {
+                        true
+                    }
+                }
+                return result
+            }
         }
     }
 

src/test/resources/inspections/JoinStatements/JoinStatementsAfter.java

@@ -48,5 +48,14 @@ public class JoinStatements {
         assertThat(iterator.next()).isEqualTo("bar");
         assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
         assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
+        assertThat(iterator.next() + "bar").isEqualTo("foobar");
+        assertThat(iterator.next() + "bar").isEqualTo("barbar");
+        int i = 0;
+        assertThat(++i).isEqualTo(1);
+        assertThat(++i).isEqualTo(2);
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
     }
 }

src/test/resources/inspections/JoinStatements/JoinStatementsBefore.java

@@ -50,5 +50,14 @@ public class JoinStatements {
         assertThat(iterator.next()).isEqualTo("bar");
         assertThat(iterator.next().toLowerCase()).isEqualTo("foo");
         assertThat(iterator.next().toLowerCase()).isEqualTo("bar");
+        assertThat(iterator.next() + "bar").isEqualTo("foobar");
+        assertThat(iterator.next() + "bar").isEqualTo("barbar");
+        int i = 0;
+        assertThat(++i).isEqualTo(1);
+        assertThat(++i).isEqualTo(2);
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(i++).toLowerCase()).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
+        assertThat(list.get(--i)).isEqualTo("foo");
     }
 }