From d9bb6a9b0b91e6ff7a56c76b76479ed40c3d2c8d Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Thu, 17 Oct 2024 10:35:45 +0200 Subject: [PATCH] Java: avoid incorrect warnings when Inlining Parameter (IDEA-345199) GitOrigin-RevId: 489422cffc7aecacd07468009da620a5732ce5ba --- .../InlineParameterExpressionProcessor.java | 29 ++++++++----------- .../inlineParameter/NoWarning.java | 17 +++++++++++ .../inlineParameter/NoWarning.java.after | 17 +++++++++++ .../RefNonStaticClassArray.java | 20 +++++++++++++ .../RefNonStaticClassArray.java.after | 20 +++++++++++++ .../inline/InlineParameterTest.java | 8 +++++ 6 files changed, 94 insertions(+), 17 deletions(-) create mode 100644 java/java-tests/testData/refactoring/inlineParameter/NoWarning.java create mode 100644 java/java-tests/testData/refactoring/inlineParameter/NoWarning.java.after create mode 100644 java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java create mode 100644 java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java.after diff --git a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java index 340fcf14d8b5..4116340d9bdd 100644 --- a/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java +++ b/java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineParameterExpressionProcessor.java @@ -332,21 +332,23 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement element = expression.resolve(); - if (element instanceof PsiMember member && !member.hasModifierProperty(PsiModifier.STATIC)) { + if (element instanceof PsiMember member && !member.hasModifierProperty(PsiModifier.STATIC) && !(member instanceof PsiClass)) { if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.dependency.unavailable.in.parameter.method", RefactoringUIUtil.getDescription(element, false))); } } - if (element instanceof PsiMethod || element instanceof PsiField) { + else if (element instanceof PsiMethod || element instanceof PsiField) { if (!mySameClass && !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.depends.on.non.static", RefactoringUIUtil.getDescription(element, true))); - } else if (!PsiUtil.isAccessible((PsiMember)element, myMethod, null)) { + } + else if (!PsiUtil.isAccessible((PsiMember)element, myMethod, null)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.dependency.unavailable.in.parameter.method", RefactoringUIUtil.getDescription(element, true))); } - } else if (element instanceof PsiParameter param && PsiTreeUtil.isAncestor(param.getDeclarationScope(), myInitializer, true)) { + } + else if (element instanceof PsiParameter param && PsiTreeUtil.isAncestor(param.getDeclarationScope(), myInitializer, true)) { boolean bound = false; for (PsiParameter parameter : myMethod.getParameterList().getParameters()) { if (parameter == myParameter) continue; @@ -381,24 +383,17 @@ public class InlineParameterExpressionProcessor extends BaseRefactoringProcessor } } - @Override - public void visitReferenceElement(@NotNull PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - if (myMethod.hasModifierProperty(PsiModifier.STATIC)) { - final PsiElement resolved = reference.resolve(); - if (resolved instanceof PsiClass cls && (PsiUtil.isInnerClass(cls) || PsiUtil.isLocalClass(cls))) { - myConflicts.putValue(reference, JavaRefactoringBundle.message("inline.parameter.depends.on.non.static.class", - RefactoringUIUtil.getDescription(resolved, true))); - } - } - } - @Override public void visitNewExpression(@NotNull PsiNewExpression expression) { super.visitNewExpression(expression); final PsiJavaCodeReferenceElement reference = expression.getClassOrAnonymousClassReference(); if (reference != null && reference.resolve() instanceof PsiClass aClass) { - if (!PsiUtil.isAccessible(aClass, myMethod, null)) { + if (!expression.isArrayCreation() && myMethod.hasModifierProperty(PsiModifier.STATIC) && + (PsiUtil.isInnerClass(aClass) || PsiUtil.isLocalClass(aClass))) { + myConflicts.putValue(reference, JavaRefactoringBundle.message("inline.parameter.depends.on.non.static.class", + RefactoringUIUtil.getDescription(aClass, true))); + } + else if (!PsiUtil.isAccessible(aClass, myMethod, null)) { myConflicts.putValue(expression, JavaRefactoringBundle.message("inline.parameter.dependency.unavailable.in.parameter.method", RefactoringUIUtil.getDescription(aClass, true))); } diff --git a/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java b/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java new file mode 100644 index 000000000000..1afa78c33a5d --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java @@ -0,0 +1,17 @@ +class MyUpdate { + + public static MyUpdate createUpdate(Container extensionsContainer) { + System.out.println("extensionsContainer = " + extensionsContainer); + return new MyUpdate(); + } + + public static void main(String[] args) { + MyUpdate.createUpdate(Container.empty()); + } +} + +class Container { + public static Container empty() { + return new Container(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java.after b/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java.after new file mode 100644 index 000000000000..8dff962d6154 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineParameter/NoWarning.java.after @@ -0,0 +1,17 @@ +class MyUpdate { + + public static MyUpdate createUpdate() { + System.out.println("extensionsContainer = " + Container.empty()); + return new MyUpdate(); + } + + public static void main(String[] args) { + MyUpdate.createUpdate(); + } +} + +class Container { + public static Container empty() { + return new Container(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java b/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java new file mode 100644 index 000000000000..571749e9a882 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java @@ -0,0 +1,20 @@ +public class ExpData { + + private Object provideObject() { + return new Object(); + } + + public static void useStatic(Object p) { + System.out.println(p); + } + + public void context() { + inlineE(new DD[10]); + } + + public static void inlineE(Object subj) { + useStatic(subj); + } + + class DD {} +} diff --git a/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java.after b/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java.after new file mode 100644 index 000000000000..95dd50fcfeeb --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineParameter/RefNonStaticClassArray.java.after @@ -0,0 +1,20 @@ +public class ExpData { + + private Object provideObject() { + return new Object(); + } + + public static void useStatic(Object p) { + System.out.println(p); + } + + public void context() { + inlineE(); + } + + public static void inlineE() { + useStatic(new DD[10]); + } + + class DD {} +} diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java index 98a446b8cab0..53ae9af047ce 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/inline/InlineParameterTest.java @@ -249,6 +249,14 @@ public class InlineParameterTest extends LightRefactoringTestCase { assertEquals("Parameter initializer depends on non-static class ExpData.DD which is not accessible inside the parameter's method", e.getMessage()); } } + + public void testRefNonStaticClassArray() { + doTest(false); + } + + public void testNoWarning() { + doTest(false); + } public void testRefThisFromStatic() { try {