Java: Don't offer "Unwrap 'else' branch" intention if it might cause unreachable code (IDEA-165428)

java/java-tests/testData/codeInsight/unwrapElseBranch/afterBlock1.java

@@ -0,0 +1,9 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            System.out.println("When true");
+        System.out.println("Otherwise");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterBlock2.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b) {
+            System.out.println("When true");
+        }
+        // Before
+        System.out.println("Otherwise");
+        // After
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterBlock3.java

@@ -0,0 +1,9 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            throw new RuntimeException("When true");
+        System.out.println("Otherwise");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterChainedIf1.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a) {
+            if (b) {
+                System.out.println("When true");
+            }
+            System.out.println("Otherwise");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterChainedIf2.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a) {
+            if (b) {
+                return "When true";
+            }
+            System.out.println("Otherwise");
+        }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterChainedIf3.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a) {
+            if (b) {
+                return "When true";
+            }
+            return "Otherwise";
+        }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterLabeled1.java

@@ -0,0 +1,15 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a) {
+            Label:
+            {
+                if (b)
+                    System.out.println("When true");
+                throw new RuntimeException("Otherwise");
+            }
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterLastReachable1.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a) {
+            if (b)
+                System.out.println("When true");
+            System.out.println("Otherwise");
+            return;
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterLastReachable2.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a) {
+            if (b)
+                System.out.println("When true");
+            return "Otherwise";
+        }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSimple1.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            System.out.println("When true");
+            // Before
+        System.out.println("Otherwise");
+        // After
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSimple2.java

@@ -0,0 +1,10 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b) {
+            System.out.println("When true");
+        }
+        System.out.println("Otherwise");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSimple3.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean b) {
+        if (b)
+            return "When true";
+            // Before
+        return "Otherwise";
+        // After
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSimple4.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    String f(boolean b) {
+        if (b)
+            System.out.println("When true");
+        else
+            return "Otherwise";
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSwitch1.java

@@ -0,0 +1,15 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                    // Before
+                System.out.println("Otherwise");
+                // After
+            case 2:
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSwitch2.java

@@ -0,0 +1,16 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                // Before
+                System.out.println("Otherwise");
+                // After
+                break;
+            case 2:
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSwitch3.java

@@ -0,0 +1,17 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                // Before
+                System.out.println("Otherwise");
+                // After
+                return;
+            case 2:
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterSynchronized1.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(Object o, boolean b) {
+        synchronized (o) {
+            if (b)
+                System.out.println("When true");
+            throw new RuntimeException("Otherwise");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/afterTry1.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        try {
+            if (b)
+                System.out.println("When true");
+            throw new RuntimeException("Otherwise");
+        } finally {
+            System.out.println("Finally");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeBlock1.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            System.out.println("When true");
+        <caret>else {
+            System.out.println("Otherwise");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeBlock2.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b) {
+            System.out.println("When true");
+        } <caret>else {
+            // Before
+            System.out.println("Otherwise");
+            // After
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeBlock3.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            throw new RuntimeException("When true");
+        <caret>else {
+            System.out.println("Otherwise");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeChainedIf1.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a)
+            if (b) {
+                System.out.println("When true");
+            } <caret>else {
+                System.out.println("Otherwise");
+            }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeChainedIf2.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a)
+            if (b) {
+                return "When true";
+            } <caret>else {
+                System.out.println("Otherwise");
+            }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeChainedIf3.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a)
+            if (b) {
+                return "When true";
+            } <caret>else {
+                return "Otherwise";
+            }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeLabeled1.java

@@ -0,0 +1,17 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a) {
+            Label:
+            {
+                if (b)
+                    System.out.println("When true");
+                <caret>else {
+                    throw new RuntimeException("Otherwise");
+                }
+            }
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeLabeled2.java

@@ -0,0 +1,15 @@
+// "Unwrap 'else' branch (changes semantics)" "false"
+
+class T {
+    void f(boolean b) {
+        Label:
+        {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                throw new RuntimeException("Otherwise");
+            }
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeLastReachable1.java

@@ -0,0 +1,14 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean a, boolean b) {
+        if (a) {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                System.out.println("Otherwise");
+                return;
+            }
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeLastReachable2.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    String f(boolean a, boolean b) {
+        if (a) {
+            if (b)
+                System.out.println("When true");
+            <caret>else
+                return "Otherwise";
+        }
+        return "Default";
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeNotLastReachable1.java

@@ -0,0 +1,14 @@
+// "Unwrap 'else' branch (changes semantics)" "false"
+
+class T {
+    void m(boolean b) {
+        if (b) {
+            System.out.println(1);
+        }
+        <caret>else {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeNotLastReachable2.java

@@ -0,0 +1,14 @@
+// "Unwrap 'else' branch" "false"
+
+class T {
+    void m(boolean b) {
+        if (b) {
+            System.out.println(1);
+        }
+        <caret>else {
+            System.out.println(2);
+            return;
+        }
+        System.out.println(3);
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSimple1.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b)
+            System.out.println("When true");
+        <caret>else
+            // Before
+            System.out.println("Otherwise");
+            // After
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSimple2.java

@@ -0,0 +1,11 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        if (b) {
+            System.out.println("When true");
+        } <caret>else {
+            System.out.println("Otherwise");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSimple3.java

@@ -0,0 +1,12 @@
+// "Unwrap 'else' branch" "true"
+
+class T {
+    String f(boolean b) {
+        if (b)
+            return "When true";
+        <caret>else
+            // Before
+            return "Otherwise";
+            // After
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSwitch1.java

@@ -0,0 +1,16 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                <caret>else
+                    // Before
+                    System.out.println("Otherwise");
+                    // After
+            case 2:
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSwitch2.java

@@ -0,0 +1,18 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                <caret>else {
+                    // Before
+                    System.out.println("Otherwise");
+                    // After
+                    break;
+                }
+            case 2:
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSwitch3.java

@@ -0,0 +1,19 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                <caret>else {
+                    // Before
+                    System.out.println("Otherwise");
+                    // After
+                    return;
+                }
+            case 2:
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSwitch4.java

@@ -0,0 +1,18 @@
+// "Unwrap 'else' branch (changes semantics)" "false"
+
+class T {
+    void f(boolean b, int n) {
+        switch (n) {
+            case 1:
+                if (b)
+                    System.out.println("When true");
+                <caret>else {
+                    // Before
+                    System.out.println("Otherwise");
+                    // After
+                    return;
+                }
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSynchronized1.java

@@ -0,0 +1,13 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(Object o, boolean b) {
+        synchronized (o) {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                throw new RuntimeException("Otherwise");
+            }
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeSynchronized2.java

@@ -0,0 +1,14 @@
+// "Unwrap 'else' branch (changes semantics)" "false"
+
+class T {
+    void f(Object o, boolean b) {
+        synchronized (o) {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                throw new RuntimeException("Otherwise");
+            }
+        }
+        System.out.println("Done");
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeTry1.java

@@ -0,0 +1,15 @@
+// "Unwrap 'else' branch (changes semantics)" "true"
+
+class T {
+    void f(boolean b) {
+        try {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                throw new RuntimeException("Otherwise");
+            }
+        } finally {
+            System.out.println("Finally");
+        }
+    }
+}

java/java-tests/testData/codeInsight/unwrapElseBranch/beforeTry2.java

@@ -0,0 +1,15 @@
+// "Unwrap 'else' branch (changes semantics)" "false"
+
+class T {
+    void f(boolean b) {
+        try {
+            if (b)
+                System.out.println("When true");
+            <caret>else {
+                throw new RuntimeException("Otherwise");
+            }
+        } finally {
+        }
+        System.out.println("Done");
+    }
+}