Java inspections: Created "Move return to computation" inspection, added a few tests (IDEA-121153)

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/LabeledFor.java

@@ -0,0 +1,13 @@
+class T {
+  int f(int[] a) {
+    int n = -1;
+    myLabel:
+    for (int i = 0; i < a.length; i++) {
+      if (a[0] == 0) {
+        n = i;
+        break myLabel;
+      }
+    }
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/LabeledFor2.java

@@ -0,0 +1,11 @@
+class T {
+  int f(int[] a) {
+    int n = -1;
+    myLabel:
+    for (int i = 0; i < a.length; i++) {
+      n = i;
+      if (a[0] == 0) break myLabel;
+    }
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/LabeledIf.java

@@ -0,0 +1,9 @@
+class T {
+  int f(boolean b) {
+    int n = 0;
+    myLabel:
+    if (b) n = 1;
+    else break myLabel;
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/NestedBlock.java

@@ -0,0 +1,9 @@
+class T {
+  int f() {
+    int n;
+    {
+      n = 1;
+    }
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/NestedBlockSideEffect.java

@@ -0,0 +1,10 @@
+class T {
+  int f() {
+    int n;
+    {
+      n = 1;
+      System.out.println();
+    }
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/NestedIf.java

@@ -0,0 +1,11 @@
+class T {
+  int f(boolean a, boolean b) {
+    int n = -1;
+    if (a) {
+      if (b) {
+        n = 1;
+      }
+    }
+    return n;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/NestedIfInnerElse.java

@@ -0,0 +1,10 @@
+class T {
+  int f(boolean a, boolean b) {
+    int n = -1;
+    if (a) {
+      if (b) n = 1;
+      else n = 2;
+    }
+    return n;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/NestedIfOuterElse.java

@@ -0,0 +1,10 @@
+class T {
+  int f(boolean a, boolean b) {
+    int n = -1;
+    if (a) {
+      if (b) n = 1;
+    }
+    else n = 2;
+    return n;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/ReturnOutsideTryWithResources.java

@@ -0,0 +1,15 @@
+import java.io.*;
+
+class T {
+  private static String getString() throws IOException {
+    String s;
+    try (BufferedReader r = open()) {
+      s = r.readLine();
+    }
+    <warning descr="Return separated from computation of value of 's'">return s;</warning>
+  }
+
+  private static BufferedReader open() throws FileNotFoundException {
+    return null;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/SimpleDoWhile.java

@@ -0,0 +1,25 @@
+class T {
+  String f(String a) {
+    String r = "";
+    int i = 0;
+    do {
+      int j = a.indexOf(",", i);
+      String s = j > i ? a.substring(i, j) : a.substring(i);
+      if (s.startsWith("@")) {
+        r = s;
+        break;
+      }
+      i = j + 1;
+    }
+    while (i >= 0);
+    <warning descr="Return separated from computation of value of 'r'">return r;</warning>
+  }
+
+  boolean hasNext() {
+    return true;
+  }
+
+  String next() {
+    return null;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/SimpleFor.java

@@ -0,0 +1,12 @@
+class T {
+  int f(int[] a, int b) {
+    int n = -1;
+    for (int i = 0; i < a.length; i++) {
+      if (a[i] == b) {
+        n = i;
+        break;
+      }
+    }
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/SimpleForeach.java

@@ -0,0 +1,12 @@
+class T {
+  String f(String[] a) {
+    String r = "";
+    for (String s : a) {
+      if (s != null && s.contains("@")) {
+        r = s + ":" + s.length();
+        break;
+      }
+    }
+    <warning descr="Return separated from computation of value of 'r'">return r;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/SimpleIf.java

@@ -0,0 +1,7 @@
+class T {
+  int f(boolean b) {
+    int n = 0;
+    if (b) n = 1;
+    <warning descr="Return separated from computation of value of 'n'">return n;</warning>
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/SimpleWhile.java

@@ -0,0 +1,21 @@
+class T {
+  String f() {
+    String r = "";
+    while (hasNext()) {
+      String s = next();
+      if (s != null) {
+        r = s;
+        break;
+      }
+    }
+    <warning descr="Return separated from computation of value of 'r'">return r;</warning>
+  }
+
+  boolean hasNext() {
+    return true;
+  }
+
+  String next() {
+    return null;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterBreakFromLoopInTryWithResources.java

@@ -0,0 +1,19 @@
+// "Move 'return' to computation of the value of 's'" "true"
+import java.io.*;
+
+class T {
+    private static String getString() throws IOException {
+        String s;
+        try (BufferedReader reader = open()) {
+            while (true) {
+                s = reader.readLine();
+                if (s == null || s.startsWith("$")) {
+                    return s;
+                }
+            }
+        }
+    }
+    private static BufferedReader open() throws FileNotFoundException {
+        return null;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterDoWhileTrue.java

@@ -0,0 +1,21 @@
+// "Move 'return' to computation of the value of 'r'" "true"
+class T {
+    String f() {
+        String r = "";
+        do {
+            if (!hasNext()) return r;
+            String s = next();
+            if (s != null) {
+                return s;
+            }
+        } while (true);
+    }
+
+    boolean hasNext() {
+        return true;
+    }
+
+    String next() {
+        return null;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterForWithoutCondition.java

@@ -0,0 +1,11 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f() {
+        int n = -1;
+        for(int i=0;; i++) {
+            if (i % 127 == 0 && i % 129 == 0) {
+                return i + 1;
+            }
+        }
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterIfElseWriteInBoth.java

@@ -0,0 +1,8 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) return 1;
+        else return 2;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterIfElseWriteInElse.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) System.out.println("yes");
+        else return 2;
+        return n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterIfElseWriteInIf.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) return 1;
+        else System.out.println("no");
+        return n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterLabeledBlock.java

@@ -0,0 +1,12 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n;
+        myLabel:
+        {
+            n = 1;
+            if (b) return n;
+            return 2;
+        }
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/afterWhileTrue.java

@@ -0,0 +1,14 @@
+// "Move 'return' to computation of the value of 'r'" "true"
+class T {
+    long f() {
+        long r;
+        long s = System.currentTimeMillis();
+        long t = s;
+        while (true) {
+            t = System.currentTimeMillis();
+            if (t - s > 100) {
+                return t;
+            }
+        }
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeAssert.java

@@ -0,0 +1,8 @@
+// "Move 'return' to computation of the value of 'n'" "false"
+class T {
+    int f(int a) {
+        int n = a;
+        assert n != 0;
+        r<caret>eturn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeBreakFromLoopInTryWithResources.java

@@ -0,0 +1,20 @@
+// "Move 'return' to computation of the value of 's'" "true"
+import java.io.*;
+
+class T {
+    private static String getString() throws IOException {
+        String s;
+        try (BufferedReader reader = open()) {
+            while (true) {
+                s = reader.readLine();
+                if (s == null || s.startsWith("$")) {
+                    break;
+                }
+            }
+        }
+        r<caret>eturn s;
+    }
+    private static BufferedReader open() throws FileNotFoundException {
+        return null;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeDoWhileTrue.java

@@ -0,0 +1,23 @@
+// "Move 'return' to computation of the value of 'r'" "true"
+class T {
+    String f() {
+        String r = "";
+        do {
+            if (!hasNext()) break;
+            String s = next();
+            if (s != null) {
+                r = s;
+                break;
+            }
+        } while (true);
+        <caret>return r;
+    }
+
+    boolean hasNext() {
+        return true;
+    }
+
+    String next() {
+        return null;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeForWithoutCondition.java

@@ -0,0 +1,13 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f() {
+        int n = -1;
+        for(int i=0;; i++) {
+            if (i % 127 == 0 && i % 129 == 0) {
+                n = i + 1;
+                break;
+            }
+        }
+        r<caret>eturn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeIfElseNoWrite.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "false"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) System.out.println("yes");
+        else System.out.println("no");
+        ret<caret>urn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeIfElseWriteInBoth.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) n = 1;
+        else n = 2;
+        r<caret>eturn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeIfElseWriteInElse.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) System.out.println("yes");
+        else n = 2;
+        r<caret>eturn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeIfElseWriteInIf.java

@@ -0,0 +1,9 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n = 0;
+        if (b) n = 1;
+        else System.out.println("no");
+        ret<caret>urn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeLabeledBlock.java

@@ -0,0 +1,13 @@
+// "Move 'return' to computation of the value of 'n'" "true"
+class T {
+    int f(boolean b) {
+        int n;
+        myLabel:
+        {
+            n = 1;
+            if (b) break myLabel;
+            n = 2;
+        }
+        ret<caret>urn n;
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/returnSeparatedFromComputation/beforeWhileTrue.java

@@ -0,0 +1,16 @@
+// "Move 'return' to computation of the value of 'r'" "true"
+class T {
+    long f() {
+        long r;
+        long s = System.currentTimeMillis();
+        long t = s;
+        while (true) {
+            t = System.currentTimeMillis();
+            if (t - s > 100) {
+                r = t;
+                break;
+            }
+        }
+        retu<caret>rn r;
+    }
+}