add support for binary operation reduction in stream migration

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterAnd.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAnd() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+      acc &= Arrays.stream(arr).reduce(-1, (a, b) -> a & b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterAndHighestBit.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndHighestBit() {
+    int[] arr = {0x80000000, 0xffffffff};
+      int acc = Arrays.stream(arr).reduce(-1, (a, b) -> a & b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterAndReplacingHexInitializer.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+      int acc = Arrays.stream(arr).reduce(0xFFFFFFFF, (a, b) -> a & b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterAndReplacingInitializer.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+      int acc = Arrays.stream(arr).reduce(-1, (a, b) -> a & b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterAndReplacingLongInitializer.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingLongInitializer() {
+    long[] arr = new long[]{1, 2, 3, 4};
+      long acc = Arrays.stream(arr).reduce(-1l, (a, b) -> a & b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterConjunction.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testConjunction() {
+    List<Boolean> booleans = new ArrayList<>();
+      boolean acc = booleans.stream().reduce(true, (a, b) -> a && b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterConjunctionBoxed.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testConjunctionBoxed() {
+    List<Boolean> booleans = new ArrayList<>();
+      Boolean acc = booleans.stream().reduce(true, (a, b) -> a && b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterDisjunction.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testDisjunction() {
+    List<Boolean> booleans = new ArrayList<>();
+      boolean acc = booleans.stream().reduce(false, (a, b) -> a || b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiply.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiply() {
+    int[] arr = new int[]{1, 2, 3, 4};
+      int acc = Arrays.stream(arr).reduce(1, (a, b) -> a * b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiplyComplexInitializer.java

@@ -0,0 +1,12 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithComplexInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int x = 10;
+    int acc = 12 + x;
+      acc *= Arrays.stream(arr).reduce(1, (a, b) -> a * b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiplyConflictingVariable.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithConflictingNamesInScope() {
+    int a = 1;
+    int b = 2;
+    int b1 = 3;
+    int[] arr = new int[]{1, 2, 3, 4};
+      int acc = Arrays.stream(arr).reduce(1, (a1, b2) -> a1 * b2);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiplyNarrowingTypeInitializer.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithNarrowingTypeInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    short acc = (byte) 12;
+      acc *= Arrays.stream(arr).map(i -> (short) i).reduce(1, (a, b) -> a * b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiplyNotOneInitializer.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithNotOneInitializerConstant() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12;
+      acc *= Arrays.stream(arr).reduce(1, (a, b) -> a * b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterMultiplyWithMapping.java

@@ -0,0 +1,10 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithMapping() {
+    int[] arr = new int[]{1, 2, 3, 4};
+      int acc = Arrays.stream(arr).map(i -> i + 2).reduce(1, (a, b) -> a * b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterOr.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseOr() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+      acc |= Arrays.stream(arr).reduce(0, (a, b) -> a | b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterXor.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseXor() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+      acc ^= Arrays.stream(arr).reduce(0, (a, b) -> a ^ b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterXorLong.java

@@ -0,0 +1,11 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseXorLong() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    long acc = 12443;
+      acc ^= Arrays.stream(arr).asLongStream().reduce(0, (a, b) -> a ^ b);
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeAnd.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAnd() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+    for <caret> (int i: arr) {
+      acc &= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeAndHighestBit.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndHighestBit() {
+    int[] arr = {0x80000000, 0xffffffff};
+    int acc = -1;
+    for <caret> (int i: arr) {
+      acc &= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeAndReplacingHexInitializer.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 0xFFFFFFFF;
+    for <caret> (int i: arr) {
+      acc &= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeAndReplacingInitializer.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = -1;
+    for <caret> (int i: arr) {
+      acc &= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeAndReplacingLongInitializer.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseAndReplacingLongInitializer() {
+    long[] arr = new long[]{1, 2, 3, 4};
+    long acc = -1l;
+    for <caret> (long i: arr) {
+      acc &= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeConjunction.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testConjunction() {
+    List<Boolean> booleans = new ArrayList<>();
+    boolean acc = true;
+    for <caret> (Boolean bool : booleans) {
+      acc &= bool;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeConjunctionBoxed.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testConjunctionBoxed() {
+    List<Boolean> booleans = new ArrayList<>();
+    Boolean acc = true;
+    for <caret> (Boolean bool : booleans) {
+      acc &= bool;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeDisjunction.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testDisjunction() {
+    List<Boolean> booleans = new ArrayList<>();
+    boolean acc = false;
+    for <caret> (Boolean bool : booleans) {
+      acc |= bool;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiply.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiply() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 1;
+    for <caret> (int i : arr) {
+      acc *= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiplyComplexInitializer.java

@@ -0,0 +1,14 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithComplexInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int x = 10;
+    int acc = 12 + x;
+    for <caret> (int i : arr) {
+      acc *= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiplyConflictingVariable.java

@@ -0,0 +1,16 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithConflictingNamesInScope() {
+    int a = 1;
+    int b = 2;
+    int b1 = 3;
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 1;
+    for <caret> (int i : arr) {
+      acc *= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiplyNarrowingTypeInitializer.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithNarrowingTypeInitializer() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    short acc = (byte) 12;
+    for <caret> (int i : arr) {
+      acc *= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiplyNotOneInitializer.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithNotOneInitializerConstant() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12;
+    for <caret> (int i : arr) {
+      acc *= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeMultiplyWithMapping.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testMultiplyWithMapping() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 1;
+    for <caret> (int i : arr) {
+      acc *= i + 2;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeOr.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseOr() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+    for <caret> (int i: arr) {
+      acc |= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeXor.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseXor() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    int acc = 12443;
+    for <caret> (int i: arr) {
+      acc ^= i;
+    }
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeXorLong.java

@@ -0,0 +1,13 @@
+// "Replace with reduce()" "true"
+
+import java.util.*;
+
+public class Main {
+  public void testBitwiseXorLong() {
+    int[] arr = new int[]{1, 2, 3, 4};
+    long acc = 12443;
+    for <caret> (int i: arr) {
+      acc ^= i;
+    }
+  }
+}