rename conflict: local variable hided by a field in an inner class (IDEA-20700)

java/java-impl/src/com/intellij/refactoring/changeSignature/ChangeSignatureProcessor.java

@@ -289,7 +289,7 @@ public class ChangeSignatureProcessor extends BaseRefactoringProcessor {
           if (!newName.equals(parameter.getName())) {
             JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions(parameter, newName, method.getBody(), null, new JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor() {
               public void visitCollidingElement(final PsiVariable collidingVariable) {
-                if (!(collidingVariable instanceof PsiField) && !deletedOrRenamedParameters.contains(collidingVariable)) {
+                if (!deletedOrRenamedParameters.contains(collidingVariable)) {
                   result.add(new RenamedParameterCollidesWithLocalUsageInfo(parameter, collidingVariable, method));
                 }
               }
@@ -300,7 +300,7 @@ public class ChangeSignatureProcessor extends BaseRefactoringProcessor {
       else {
         JavaUnresolvableLocalCollisionDetector.visitLocalsCollisions(method, newName, method.getBody(), null, new JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor() {
           public void visitCollidingElement(PsiVariable collidingVariable) {
-            if (!(collidingVariable instanceof PsiField) && !deletedOrRenamedParameters.contains(collidingVariable)) {
+            if (!deletedOrRenamedParameters.contains(collidingVariable)) {
               result.add(new NewParameterCollidesWithLocalUsageInfo(collidingVariable, collidingVariable, method));
             }
           }

java/java-impl/src/com/intellij/refactoring/introduceVariable/InputValidator.java

@@ -18,7 +18,6 @@ package com.intellij.refactoring.introduceVariable;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiExpression;
-import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiVariable;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.rename.JavaUnresolvableLocalCollisionDetector;
@@ -49,7 +48,6 @@ public class InputValidator implements IntroduceVariableBase.Validator {
     final HashSet<PsiVariable> reportedVariables = new HashSet<PsiVariable>();
     JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor visitor = new JavaUnresolvableLocalCollisionDetector.CollidingVariableVisitor() {
       public void visitCollidingElement(PsiVariable collidingVariable) {
-        if (collidingVariable instanceof PsiField) return;
         if (!reportedVariables.contains(collidingVariable)) {
           reportedVariables.add(collidingVariable);
           String message = RefactoringBundle.message("introduced.variable.will.conflict.with.0", RefactoringUIUtil.getDescription(collidingVariable, true));

java/java-impl/src/com/intellij/refactoring/rename/JavaUnresolvableLocalCollisionDetector.java

@@ -51,7 +51,7 @@ public class JavaUnresolvableLocalCollisionDetector {
 
     final CollidingVariableVisitor collidingNameVisitor = new CollidingVariableVisitor() {
       public void visitCollidingElement(PsiVariable collidingVariable) {
-        if (collidingVariable.equals(element) || collidingVariable instanceof PsiField) return;
+        if (collidingVariable.equals(element)) return;
         LocalHidesRenamedLocalUsageInfo collision = new LocalHidesRenamedLocalUsageInfo(element, collidingVariable);
         result.add(collision);
       }
@@ -116,9 +116,6 @@ public class JavaUnresolvableLocalCollisionDetector {
           current = current.getParent();
         }
       }
-    }
-
-    if (collidingVariable != null) {
       collidingNameVisitor.visitCollidingElement(collidingVariable);
     }
   }
@@ -136,7 +133,11 @@ public class JavaUnresolvableLocalCollisionDetector {
       visitElement(expression);
     }
 
-    @Override public void visitClass(PsiClass aClass) {
+    @Override
+    public void visitField(PsiField field) {
+      if (myName.equals(field.getName())) {
+        myCollidingNameVisitor.visitCollidingElement(field);
+      }
     }
 
     @Override public void visitVariable(PsiVariable variable) {

java/java-tests/testData/refactoring/renameCollisions/RenameLocalVariableHidesFieldInAnonymous.java

@@ -0,0 +1,16 @@
+public class A {
+  Thread m() {
+    final int x<caret> = 42;
+    return new Thread() {
+      int y = 23;
+
+      public void run() {
+        System.out.println(x);
+      }
+    };
+  }
+
+  public static void main(String[] args) {
+    new A().m().start();
+  }
+}

java/java-tests/testSrc/com/intellij/refactoring/RenameCollisionsTest.java

@@ -7,6 +7,7 @@ import com.intellij.openapi.projectRoots.impl.JavaSdkImpl;
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.rename.RenameProcessor;
 import com.intellij.testFramework.LightCodeInsightTestCase;
+import org.junit.Assert;
 
 /**
  * @author sashache
@@ -140,6 +141,17 @@ public class RenameCollisionsTest extends LightCodeInsightTestCase {
     doTest("STATIC_FIELD");
   }
 
+  public void testRenameLocalVariableHidesFieldInAnonymous() throws Exception {
+    try {
+      doTest("y");
+    }
+    catch (BaseRefactoringProcessor.ConflictsInTestsException e) {
+      Assert.assertEquals("There is already a field <b><code>y</code></b>. It will conflict with the renamed variable", e.getMessage());
+      return;
+    }
+    fail("Conflicts were not found");
+  }
+
   private void doTest(final String newName) throws Exception {
     configureByFile(BASE_PATH + getTestName(false) + ".java");
     PsiElement element = TargetElementUtilBase

platform/lang-impl/src/com/intellij/refactoring/rename/RenameProcessor.java

@@ -16,6 +16,7 @@
 
 package com.intellij.refactoring.rename;
 
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.progress.ProgressManager;
@@ -121,6 +122,9 @@ public class RenameProcessor extends BaseRefactoringProcessor {
     RenameUtil.addConflictDescriptions(usagesIn, conflicts);
     RenamePsiElementProcessor.forElement(myPrimaryElement).findExistingNameConflicts(myPrimaryElement, myNewName, conflicts);
     if (!conflicts.isEmpty()) {
+      if (ApplicationManager.getApplication().isUnitTestMode()) {
+        throw new ConflictsInTestsException(conflicts.values());
+      }
       ConflictsDialog conflictsDialog = new ConflictsDialog(myProject, conflicts);
       conflictsDialog.show();
       if (!conflictsDialog.isOK()) {