[java-refactoring] Inline variable: improve behavior in the presence of compilation errors

1. Properly forward the AnalysisCancelledException
2. Allow inlining of never overwritten variable in the presence of syntax errors

Fixes IDEA-336815 "Inline variable" misleading error message when compile-errors are present

GitOrigin-RevId: 7510d497fce2dcd4bef38482cfadf162d47cc2c0

java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineLocalHandler.java

@@ -199,14 +199,26 @@ public class InlineLocalHandler extends JavaInlineActionHandler {
     }
 
     List<PsiElement> refsToInlineList = new ArrayList<>();
+    boolean simpleInlining = false;
     if (mode == InlineMode.INLINE_ONE) {
       refsToInlineList.add(refExpr);
     } else {
-      try {
-        Collections.addAll(refsToInlineList, DefUseUtil.getRefs(containerBlock, local, defToInline));
+      if (defToInline == local.getInitializer()) {
+        // Do not rely on ref-def analysis in a simple case when we inline an initializer and there are no subsequent writes.
+        // This allows inlining in the presense of syntax errors.
+        List<PsiReferenceExpression> refs = VariableAccessUtils.getVariableReferences(local, containerBlock);
+        if (!ContainerUtil.exists(refs, ref -> PsiUtil.isAccessedForWriting(ref))) {
+          simpleInlining = true;
+          refsToInlineList.addAll(refs);
+        }
       }
-      catch (RuntimeException e) {
-        return processWrappedAnalysisCanceledException(e);
+      if (!simpleInlining) {
+        try {
+          Collections.addAll(refsToInlineList, DefUseUtil.getRefs(containerBlock, local, defToInline, true));
+        }
+        catch (RuntimeException e) {
+          return processWrappedAnalysisCanceledException(e);
+        }
       }
       for (PsiElement innerClassUsage : innerClassUses.innerClassUsages()) {
         if (!refsToInlineList.contains(innerClassUsage)) {

java/java-tests/testData/refactoring/inlineLocal/CompilationError.java

@@ -0,0 +1,11 @@
+public class CompilationError {
+
+  public void test() {
+    public static void main(String[] args) {
+      int <caret>inlineMe = 3; // inline
+      int dd = 4 + inlineMe;
+
+      "Error".
+    }
+  }
+}

java/java-tests/testData/refactoring/inlineLocal/CompilationError.java.after

@@ -0,0 +1,11 @@
+public class CompilationError {
+
+  public void test() {
+    public static void main(String[] args) {
+          // inline
+          int dd = 4 + 3;
+
+      "Error".
+    }
+  }
+}

java/java-tests/testData/refactoring/inlineLocal/CompilationErrorAssignment.java

@@ -0,0 +1,12 @@
+public class CompilationError {
+
+  public void test() {
+    public static void main(String[] args) {
+      int inlineMe = 2;
+      <caret>inlineMe = 3; // inline
+      int dd = 4 + inlineMe;
+
+      "Error".
+    }
+  }
+}

java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineLocalTest.java

@@ -342,6 +342,15 @@ public class InlineLocalTest extends LightJavaCodeInsightTestCase {
   public void testUnusedReassignmentInLoop() {
     doTest();
   }
+  
+  public void testCompilationError() {
+    doTest();
+  }
+
+  public void testCompilationErrorAssignment() {
+    doTest("Cannot perform refactoring.\n" +
+           "Code contains syntax errors. Cannot perform necessary analysis.");
+  }
 
   public void testEolComment() {
     doTest();