From 2348703c48e510f6d21b65a777f708a118c9169f Mon Sep 17 00:00:00 2001 From: Sergey Evdokimov Date: Mon, 10 Sep 2012 13:53:14 +0400 Subject: [PATCH 1/5] EA-35760 - assert: ComponentManagerImpl.getComponent --- .../ide/util/gotoByName/ContributorsBasedGotoByModel.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ContributorsBasedGotoByModel.java b/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ContributorsBasedGotoByModel.java index 511ab47892c5..25b2d4cb2d8f 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ContributorsBasedGotoByModel.java +++ b/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ContributorsBasedGotoByModel.java @@ -120,6 +120,10 @@ public abstract class ContributorsBasedGotoByModel implements ChooseByNameModel Processor processor = new Processor() { @Override public boolean process(ChooseByNameContributor contributor) { + if (myProject.isDisposed()) { + return true; + } + try { for (NavigationItem item : contributor.getItemsByName(name, pattern, myProject, checkBoxState)) { if (item == null) { From 10080b4da6c81d1e087f857147e5f90afebb86e6 Mon Sep 17 00:00:00 2001 From: Sergey Evdokimov Date: Mon, 10 Sep 2012 14:41:42 +0400 Subject: [PATCH 2/5] Add additional diagnostic. --- .../jetbrains/idea/maven/importing/MavenModuleNameMapper.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleNameMapper.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleNameMapper.java index 8dc522ffe1f2..71f6c9bef24b 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleNameMapper.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleNameMapper.java @@ -74,7 +74,8 @@ public class MavenModuleNameMapper { for (NameItem name : names) { if (name.module != null) { - existingNames.add(name.getResultName()); + boolean wasAdded = existingNames.add(name.getResultName()); + assert wasAdded : name.getResultName(); } } From 59d8cbc6fb4329243c1655cb36685b0da0f669f6 Mon Sep 17 00:00:00 2001 From: Max Medvedev Date: Mon, 10 Sep 2012 13:57:33 +0400 Subject: [PATCH 3/5] IDEA-90724 'Safe Delete' refactoring of java method parameter from doesn't delete it from groovy calls --- .../JavaSafeDeleteDelegateImpl.java | 90 +++++++++++++++++++ .../safeDelete/JavaSafeDeleteProcessor.java | 55 +----------- .../safeDelete/JavaSafeDeleteDelegate.java | 37 ++++++++ plugins/groovy/src/META-INF/plugin.xml | 1 + .../psi/api/GrDocMethodReference.java | 5 ++ .../psi/impl/GrDocMethodReferenceImpl.java | 17 +++- .../JavaSafeDeleteDelegateForGroovy.java | 90 +++++++++++++++++++ .../SafeDeleteJavaParameterTest.groovy | 73 +++++++++++++++ resources/src/META-INF/IdeaPlugin.xml | 3 + 9 files changed, 317 insertions(+), 54 deletions(-) create mode 100644 java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegateImpl.java create mode 100644 java/openapi/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegate.java create mode 100644 plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/safeDelete/JavaSafeDeleteDelegateForGroovy.java create mode 100644 plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/safeDelete/SafeDeleteJavaParameterTest.groovy diff --git a/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegateImpl.java b/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegateImpl.java new file mode 100644 index 000000000000..ca1a1d5e8618 --- /dev/null +++ b/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegateImpl.java @@ -0,0 +1,90 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.refactoring.safeDelete; + +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.*; +import com.intellij.psi.impl.source.javadoc.PsiDocMethodOrFieldRef; +import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceJavaDeleteUsageInfo; +import com.intellij.usageView.UsageInfo; +import com.intellij.util.Function; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NonNls; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @author Max Medvedev + */ +public class JavaSafeDeleteDelegateImpl implements JavaSafeDeleteDelegate { + @Override + public void createUsageInfoForParameter(final PsiReference reference, + final List usages, + final PsiParameter parameter, + final PsiMethod method) { + int index = method.getParameterList().getParameterIndex(parameter); + final PsiElement element = reference.getElement(); + PsiCall call = null; + if (element instanceof PsiCall) { + call = (PsiCall)element; + } + else if (element.getParent() instanceof PsiCall) { + call = (PsiCall)element.getParent(); + } + if (call != null) { + final PsiExpressionList argList = call.getArgumentList(); + if (argList != null) { + final PsiExpression[] args = argList.getExpressions(); + if (index < args.length) { + if (!parameter.isVarArgs()) { + usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(args[index], parameter, true)); + } + else { + for (int i = index; i < args.length; i++) { + usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(args[i], parameter, true)); + } + } + } + } + } + else if (element instanceof PsiDocMethodOrFieldRef) { + if (((PsiDocMethodOrFieldRef)element).getSignature() != null) { + @NonNls final StringBuffer newText = new StringBuffer(); + newText.append("/** @see #").append(method.getName()).append('('); + final List parameters = new ArrayList(Arrays.asList(method.getParameterList().getParameters())); + parameters.remove(parameter); + newText.append(StringUtil.join(parameters, new Function() { + @Override + public String fun(PsiParameter psiParameter) { + return parameter.getType().getCanonicalText(); + } + }, ",")); + newText.append(")*/"); + usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(element, parameter, true) { + public void deleteElement() throws IncorrectOperationException { + final PsiDocMethodOrFieldRef.MyReference javadocMethodReference = + (PsiDocMethodOrFieldRef.MyReference)element.getReference(); + if (javadocMethodReference != null) { + javadocMethodReference.bindToText(method.getContainingClass(), newText); + } + } + }); + } + } + } +} diff --git a/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteProcessor.java b/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteProcessor.java index 84d7a4b0a1bf..0ffba36a732d 100644 --- a/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteProcessor.java @@ -26,11 +26,9 @@ import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.ui.Messages; import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.TextRange; -import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.VariableKind; -import com.intellij.psi.impl.source.javadoc.PsiDocMethodOrFieldRef; import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.psi.search.searches.ReferencesSearch; @@ -47,11 +45,9 @@ import com.intellij.usageView.UsageInfo; import com.intellij.usageView.UsageViewUtil; import com.intellij.usages.*; import com.intellij.util.ArrayUtil; -import com.intellij.util.Function; import com.intellij.util.IncorrectOperationException; import com.intellij.util.Processor; import com.intellij.util.containers.HashMap; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.Nullable; import java.util.*; @@ -681,56 +677,12 @@ public class JavaSafeDeleteProcessor extends SafeDeleteProcessorDelegateBase { private static void findParameterUsages(final PsiParameter parameter, final List usages) { final PsiMethod method = (PsiMethod)parameter.getDeclarationScope(); - final int index = method.getParameterList().getParameterIndex(parameter); //search for refs to current method only, do not search for refs to overriding methods, they'll be searched separately ReferencesSearch.search(method).forEach(new Processor() { public boolean process(final PsiReference reference) { - final PsiElement element = reference.getElement(); - PsiCall call = null; - if (element instanceof PsiCall) { - call = (PsiCall)element; - } else if (element.getParent() instanceof PsiCall) { - call = (PsiCall)element.getParent(); - } - if (call != null) { - final PsiExpressionList argList = call.getArgumentList(); - if (argList != null) { - final PsiExpression[] args = argList.getExpressions(); - if (index < args.length) { - if (!parameter.isVarArgs()) { - usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(args[index], parameter, true)); - } - else { - for (int i = index; i < args.length; i++) { - usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(args[i], parameter, true)); - } - } - } - } - } - else if (element instanceof PsiDocMethodOrFieldRef) { - if (((PsiDocMethodOrFieldRef)element).getSignature() != null) { - @NonNls final StringBuffer newText = new StringBuffer(); - newText.append("/** @see #").append(method.getName()).append('('); - final List parameters = new ArrayList(Arrays.asList(method.getParameterList().getParameters())); - parameters.remove(parameter); - newText.append(StringUtil.join(parameters, new Function() { - @Override - public String fun(PsiParameter psiParameter) { - return parameter.getType().getCanonicalText(); - } - }, ",")); - newText.append(")*/"); - usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(element, parameter, true) { - public void deleteElement() throws IncorrectOperationException { - final PsiDocMethodOrFieldRef.MyReference javadocMethodReference = - (PsiDocMethodOrFieldRef.MyReference)element.getReference(); - if (javadocMethodReference != null) { - javadocMethodReference.bindToText(method.getContainingClass(), newText); - } - } - }); - } + PsiElement element = reference.getElement(); + if (element != null) { + JavaSafeDeleteDelegate.EP.forLanguage(element.getLanguage()).createUsageInfoForParameter(reference, usages, parameter, method); } return true; } @@ -766,6 +718,7 @@ public class JavaSafeDeleteProcessor extends SafeDeleteProcessorDelegateBase { }); } + private static boolean isInside(PsiElement place, PsiElement[] ancestors) { return isInside(place, Arrays.asList(ancestors)); } diff --git a/java/openapi/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegate.java b/java/openapi/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegate.java new file mode 100644 index 000000000000..af731fb8bccd --- /dev/null +++ b/java/openapi/src/com/intellij/refactoring/safeDelete/JavaSafeDeleteDelegate.java @@ -0,0 +1,37 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.refactoring.safeDelete; + +import com.intellij.lang.LanguageExtension; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiParameter; +import com.intellij.psi.PsiReference; +import com.intellij.usageView.UsageInfo; + +import java.util.List; + +/** + * @author Max Medvedev + */ +public interface JavaSafeDeleteDelegate { + LanguageExtension EP = + new LanguageExtension("com.intellij.refactoring.safeDelete.JavaSafeDeleteDelegate"); + + void createUsageInfoForParameter(final PsiReference reference, + final List usages, + final PsiParameter parameter, + final PsiMethod method); +} diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml index c47140ec7ac0..e1c04efa8a23 100644 --- a/plugins/groovy/src/META-INF/plugin.xml +++ b/plugins/groovy/src/META-INF/plugin.xml @@ -165,6 +165,7 @@ implementation="org.jetbrains.plugins.groovy.refactoring.changeSignature.GrChangeSignatureUsageProcessor" id="groovyProcessor" order="before javaProcessor"/> + diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/api/GrDocMethodReference.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/api/GrDocMethodReference.java index 37fbd9f7db2f..0468e6fd291f 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/api/GrDocMethodReference.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/api/GrDocMethodReference.java @@ -16,6 +16,9 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.psi.api; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; /** @@ -25,4 +28,6 @@ public interface GrDocMethodReference extends GrDocMemberReference{ @NotNull GrDocMethodParams getParameterList(); + + PsiElement bindToText(Project project, String text); } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/impl/GrDocMethodReferenceImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/impl/GrDocMethodReferenceImpl.java index 8fa7aee0e1d0..1cd0dea9eb6d 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/impl/GrDocMethodReferenceImpl.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/psi/impl/GrDocMethodReferenceImpl.java @@ -17,16 +17,18 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.psi.impl; import com.intellij.lang.ASTNode; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; import com.intellij.psi.*; +import com.intellij.psi.javadoc.PsiDocComment; import com.intellij.psi.util.PropertyUtil; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocMethodParams; -import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocMethodReference; -import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocReferenceElement; +import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.*; import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor; +import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory; import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement; import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil; import org.jetbrains.plugins.groovy.lang.resolve.processors.MethodResolverProcessor; @@ -55,6 +57,15 @@ public class GrDocMethodReferenceImpl extends GrDocMemberReferenceImpl implement return child; } + @Override + public PsiElement bindToText(Project project, String text) { + GrDocComment comment = GroovyPsiElementFactory.getInstance(project).createDocCommentFromText(text); + PsiElement tag = PsiTreeUtil.getChildOfType(comment, GrDocTag.class); + PsiElement ref = PsiTreeUtil.getChildOfType(tag, GrDocMethodReference.class); + assert ref != null : text; + return replace(ref); + } + @Override public PsiElement resolve() { String name = getReferenceName(); diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/safeDelete/JavaSafeDeleteDelegateForGroovy.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/safeDelete/JavaSafeDeleteDelegateForGroovy.java new file mode 100644 index 000000000000..c39326d4a26d --- /dev/null +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/safeDelete/JavaSafeDeleteDelegateForGroovy.java @@ -0,0 +1,90 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jetbrains.plugins.groovy.refactoring.safeDelete; + +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.*; +import com.intellij.refactoring.safeDelete.JavaSafeDeleteDelegate; +import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceJavaDeleteUsageInfo; +import com.intellij.usageView.UsageInfo; +import com.intellij.util.Function; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocMethodReference; +import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocReferenceElement; +import org.jetbrains.plugins.groovy.lang.psi.api.signatures.GrClosureSignature; +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall; +import org.jetbrains.plugins.groovy.lang.psi.impl.signatures.GrClosureSignatureUtil; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @author Max Medvedev + */ +public class JavaSafeDeleteDelegateForGroovy implements JavaSafeDeleteDelegate { + @Override + public void createUsageInfoForParameter(PsiReference reference, + List usages, + final PsiParameter parameter, + final PsiMethod method) { + int index = method.getParameterList().getParameterIndex(parameter); + final PsiElement element = reference.getElement(); + GrCall call = null; + if (element instanceof GrCall) { + call = (GrCall)element; + } + else if (element.getParent() instanceof GrCall) { + call = (GrCall)element.getParent(); + } + if (call != null) { + GrClosureSignature signature = GrClosureSignatureUtil.createSignature(call); + if (signature == null) return;//todo ??? + GrClosureSignatureUtil.ArgInfo[] argInfos = GrClosureSignatureUtil.mapParametersToArguments(signature, call); + if (argInfos == null) return; //todo??? + + for (PsiElement arg : argInfos[index].args) { + usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(arg, parameter, true)); + } + } + else if (element instanceof GrDocMethodReference) { + @NonNls final StringBuilder newText = new StringBuilder(); + newText.append("/** @see "); + GrDocReferenceElement holder = ((GrDocMethodReference)element).getReferenceHolder(); + if (holder != null) { + newText.append(holder.getText()); + } + newText.append('#'); + newText.append(method.getName()); + newText.append('('); + final List parameters = new ArrayList(Arrays.asList(method.getParameterList().getParameters())); + parameters.remove(parameter); + newText.append(StringUtil.join(parameters, new Function() { + @Override + public String fun(PsiParameter psiParameter) { + return parameter.getType().getCanonicalText(); + } + }, ",")); + newText.append(")*/"); + usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(element, parameter, true) { + public void deleteElement() throws IncorrectOperationException { + ((GrDocMethodReference)element).bindToText(method.getProject(), newText.toString()); + } + }); + } + } +} diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/safeDelete/SafeDeleteJavaParameterTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/safeDelete/SafeDeleteJavaParameterTest.groovy new file mode 100644 index 000000000000..6c6c0bc82e89 --- /dev/null +++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/safeDelete/SafeDeleteJavaParameterTest.groovy @@ -0,0 +1,73 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jetbrains.plugins.groovy.refactoring.safeDelete + +import com.intellij.codeInsight.TargetElementUtilBase +import com.intellij.psi.PsiElement +import com.intellij.refactoring.safeDelete.SafeDeleteHandler +import com.intellij.refactoring.safeDelete.SafeDeleteProcessor +import org.jetbrains.plugins.groovy.LightGroovyTestCase +import org.jetbrains.plugins.groovy.util.TestUtils; + +/** + * @author Max Medvedev + */ +public class SafeDeleteJavaParameterTest extends LightGroovyTestCase { + + final String basePath = TestUtils.testDataPath + "refactoring/safeDeleteJavaParameter/" + + void testGroovyCall() { + doTest('''\ +class A { + void foo(int bar) {} +} +''', '''\ +new A().foo(2) +''', '''\ +new A().foo() +''') + } + + void testGroovyDocRef() { + doTest('''\ +class A { + void foo(int bar) {} +} +''', '''\ +/** +@see A#foo(int) +*/ +class X{} +''', '''\ +/** +@see A#foo() +*/ +class X{} +''') + } + + private void doTest(String java, String groovy, String groovyAfter) { + myFixture.configureByText('test.java', java) + def groovyFile = myFixture.addFileToProject('test.groovy', groovy) + + final PsiElement psiElement = TargetElementUtilBase + .findTargetElement(myFixture.editor, TargetElementUtilBase.ELEMENT_NAME_ACCEPTED | TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED); + + SafeDeleteHandler.invoke(myFixture.project, [psiElement] as PsiElement[], true) + + assertEquals(groovyAfter, groovyFile.text) + } +} diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index 929f2a5e4555..93c161b20774 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -155,6 +155,8 @@ + + @@ -1096,6 +1098,7 @@ + From 0292d5471f2722816168887d882d7d4a513de3a0 Mon Sep 17 00:00:00 2001 From: Max Medvedev Date: Mon, 10 Sep 2012 14:48:45 +0400 Subject: [PATCH 4/5] fix testdata --- .../convertGroovyToJava/codeBlock/closure.java | 2 +- .../refactoring/convertGroovyToJava/file/anonymous2.java | 2 +- .../convertGroovyToJava/file/closureInUse.java | 6 +++--- .../refactoring/convertGroovyToJava/file/constructor.java | 2 +- .../convertGroovyToJava/file/dynamicMethodsAccess.java | 4 ++-- .../convertGroovyToJava/file/dynamicPropertiesAccess.java | 8 ++++---- .../refactoring/convertGroovyToJava/file/hash.java | 2 +- .../file/methodParamInClosureImplicitReturn.java | 4 ++-- .../convertGroovyToJava/file/refInClosureInMethod.java | 6 +++--- .../convertGroovyToJava/file/refInClosureInScript.java | 2 +- .../refactoring/convertGroovyToJava/file/returns.java | 6 +++--- .../convertGroovyToJava/file/staticProperty.java | 2 +- 12 files changed, 23 insertions(+), 23 deletions(-) diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java index 15d0b91c2466..fee12b6cf1e7 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java @@ -1,7 +1,7 @@ java.util.ArrayList list = new java.util.ArrayList(java.util.Arrays.asList(1, 2, 3)); org.codehaus.groovy.runtime.DefaultGroovyMethods.each(list, new groovy.lang.Closure(this, this) { public void doCall(java.lang.Object it) { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(closure.this, it); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, it); } public void doCall() { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/anonymous2.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/anonymous2.java index a2d9b2657fde..ac77dd94f7f3 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/anonymous2.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/anonymous2.java @@ -1,6 +1,6 @@ public abstract class Anon extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public Anon(java.lang.Object foo) { -Anon.this.foo = foo; +this.foo = foo; } public abstract void run() ; public java.lang.Object getFoo() { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/closureInUse.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/closureInUse.java index e040fd63c0bc..e5208d74e788 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/closureInUse.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/closureInUse.java @@ -1,10 +1,10 @@ public class IntCat extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public static void call(java.lang.Integer i) { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(IntCat.this, i); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, i); } public static void call(java.lang.Integer i, java.lang.String s) { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(IntCat.this, s); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, s); } } @@ -14,7 +14,7 @@ new closureInUse(new groovy.lang.Binding(args)).run(); } public java.lang.Object run() { -return org.codehaus.groovy.runtime.DefaultGroovyMethods.use(closureInUse.this, IntCat.class, new groovy.lang.Closure(this, this) { +return org.codehaus.groovy.runtime.DefaultGroovyMethods.use(this, IntCat.class, new groovy.lang.Closure(this, this) { public void doCall(java.lang.Object it) { IntCat.call(2); IntCat.call(2, "a"); diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/constructor.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/constructor.java index f939f9f8850e..31fe43caeb6c 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/constructor.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/constructor.java @@ -5,6 +5,6 @@ public Base(java.lang.Object a) { public class Inheritor extends Base implements groovy.lang.GroovyObject { public Inheritor(int x, int y) { super(x); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(Inheritor.this, y); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, y); } } diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicMethodsAccess.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicMethodsAccess.java index 71865d71fd0f..e46f580c4751 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicMethodsAccess.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicMethodsAccess.java @@ -3,10 +3,10 @@ public java.lang.Object foo() { invokeMethod("bar", new java.lang.Object[]{2}); java.util.LinkedHashMap map = new java.util.LinkedHashMap(1); map.put("s", 4); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(Abc.this, invokeMethod("bar", new java.lang.Object[]{map, 3})); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, invokeMethod("bar", new java.lang.Object[]{map, 3})); java.lang.String s = "a"; org.codehaus.groovy.runtime.DefaultGroovyMethods.invokeMethod(s, "bar", new java.lang.Object[]{4}); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(Abc.this, org.codehaus.groovy.runtime.DefaultGroovyMethods.invokeMethod(s, "bar", new java.lang.Object[]{5})); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, org.codehaus.groovy.runtime.DefaultGroovyMethods.invokeMethod(s, "bar", new java.lang.Object[]{5})); return org.codehaus.groovy.runtime.DefaultGroovyMethods.invokeMethod(s, "anme", new java.util.ArrayList()); } diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicPropertiesAccess.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicPropertiesAccess.java index 14da1caec17c..34b1830d6ced 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicPropertiesAccess.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/dynamicPropertiesAccess.java @@ -1,12 +1,12 @@ public class A extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public void foo() { setProperty("bar", 2); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(A.this, setProperty0(A.this, "bar", 3)); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, setProperty0(this, "bar", 3)); java.lang.String s = "a"; s.bar = 4; -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(A.this, s.bar = 5); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(A.this, getProperty("bar")); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(A.this, s.getProperty("bar")); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, s.bar = 5); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, getProperty("bar")); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, s.getProperty("bar")); } private static Value setProperty0(groovy.lang.GroovyObjectSupport propOwner, java.lang.String property, Value newValue) { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/hash.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/hash.java index a333176b0dd7..5ff1d39e4fdd 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/hash.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/hash.java @@ -29,7 +29,7 @@ new hash(new groovy.lang.Binding(args)).run(); public java.lang.Object run() { int KB = 1024; int MB = 1024 * KB; -java.io.File f = new java.io.File(hash.this.getBinding().getProperty("args")[0]); +java.io.File f = new java.io.File(this.getBinding().getProperty("args")[0]); if (!org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean(f.exists()) || !org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean(f.isFile())){ println("Invalid file " + java.lang.String.valueOf(f) + " provided"); println("Usage: groovy sha1.groovy "); diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java index 801ad5308258..94756942eaa3 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java @@ -12,7 +12,7 @@ public void foo(int x) { final groovy.lang.Reference i = new groovy.lang.Reference(x); org.codehaus.groovy.runtime.DefaultGroovyMethods.each(new java.util.ArrayList(java.util.Arrays.asList(1, 2, 3)), new groovy.lang.Closure(this, this) { public java.lang.Number doCall(java.lang.Object it) { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(methodParamInClosureImplicitReturn.this, i.get()); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, i.get()); return setGroovyRef(i, i.get() + 1); } @@ -23,7 +23,7 @@ return doCall(null); }); org.codehaus.groovy.runtime.DefaultGroovyMethods.each(new java.util.ArrayList(java.util.Arrays.asList(1, 2, 3)), new groovy.lang.Closure(this, this) { public java.lang.Integer doCall(java.lang.Object it) { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(methodParamInClosureImplicitReturn.this, i.get()); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, i.get()); i.set(i.get()++); return i.get(); } diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInMethod.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInMethod.java index 7e23fae31b55..7f30dbb60f3a 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInMethod.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInMethod.java @@ -1,9 +1,9 @@ public class X extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public void foo() { final groovy.lang.Reference ab = new groovy.lang.Reference(4); -org.codehaus.groovy.runtime.DefaultGroovyMethods.each(X.this, new groovy.lang.Closure(this, this) { +org.codehaus.groovy.runtime.DefaultGroovyMethods.each(this, new groovy.lang.Closure(this, this) { public java.lang.Object doCall(java.lang.Object it) { -return org.codehaus.groovy.runtime.DefaultGroovyMethods.each(X.this, new groovy.lang.Closure(this, this) { +return org.codehaus.groovy.runtime.DefaultGroovyMethods.each(this, new groovy.lang.Closure(this, this) { public java.lang.Integer doCall(java.lang.Object it) { return setGroovyRef(ab, 2); } @@ -20,7 +20,7 @@ return doCall(null); } }); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(X.this, ab.get()); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, ab.get()); } private static T setGroovyRef(groovy.lang.Reference ref, T newValue) { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java index 4b81506a473d..4963dbcfdfe4 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java @@ -11,7 +11,7 @@ foo.set(foo.get()++); foo.set(foo.get() + 2); foo.set(foo.get() - 1); foo.set(4); -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(refInClosureInScript.this, foo.get()); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, foo.get()); } public void doCall() { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/returns.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/returns.java index 48a66f58393c..1d28b8d9b4d9 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/returns.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/returns.java @@ -1,14 +1,14 @@ public class returns extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public void foo1() { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(returns.this, "foo"); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, "foo"); } public void foo2() { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(returns.this, "foo"); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, "foo"); } public int foo3() { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(returns.this, "foo"); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, "foo"); } public java.lang.Integer foo4() { diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/staticProperty.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/staticProperty.java index 5cf1b6ba5be4..718d61b9169c 100644 --- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/staticProperty.java +++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/staticProperty.java @@ -1,6 +1,6 @@ public class Foo extends groovy.lang.GroovyObjectSupport implements groovy.lang.GroovyObject { public void print() { -org.codehaus.groovy.runtime.DefaultGroovyMethods.print(Foo.this, CONST); +org.codehaus.groovy.runtime.DefaultGroovyMethods.print(this, CONST); } public static java.lang.Integer getCONST() { From b665d21263f8180441bfc8b4f7998caaca8f4d3f Mon Sep 17 00:00:00 2001 From: Anna Kozlova Date: Mon, 10 Sep 2012 14:57:44 +0400 Subject: [PATCH 5/5] anonym -> lambda: decode context correctly --- .../AnonymousCanBeLambdaInspection.java | 77 +++++++++++++------ .../afterComparableNeedToBeFinal.java | 14 ++-- .../afterMultilineComparable.java | 4 +- .../afterNeedToQualifyAccess.java | 16 ++++ .../anonymous2lambda/afterRunnable.java | 2 +- .../afterRunnableInArrayInitializer.java | 2 +- .../beforeFieldInAnonymous.java | 18 +++++ .../beforeNeedToQualifyAccess.java | 19 +++++ 8 files changed, 118 insertions(+), 34 deletions(-) create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterNeedToQualifyAccess.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFieldInAnonymous.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNeedToQualifyAccess.java diff --git a/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java b/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java index 99699e9a1a47..594f73db7b07 100644 --- a/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java @@ -15,18 +15,16 @@ */ package com.intellij.codeInspection; +import com.intellij.codeInsight.ChangeContextUtil; import com.intellij.codeInsight.daemon.GroupNames; -import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil; import com.intellij.codeInsight.intention.HighPriorityAction; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; -import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; -import com.intellij.psi.util.RedundantCastUtil; import com.intellij.util.Function; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; @@ -74,7 +72,7 @@ public class AnonymousCanBeLambdaInspection extends BaseJavaLocalInspectionTool final String functionalInterfaceErrorMessage = LambdaUtil.checkInterfaceFunctional(baseClassType); if (functionalInterfaceErrorMessage == null) { final PsiMethod[] methods = aClass.getMethods(); - if (methods.length == 1) { + if (methods.length == 1 && aClass.getFields().length == 0) { final PsiCodeBlock body = methods[0].getBody(); if (body != null) { final boolean [] bodyContainsForbiddenRefs = new boolean[1]; @@ -128,7 +126,7 @@ public class AnonymousCanBeLambdaInspection extends BaseJavaLocalInspectionTool if (element != null) { final PsiAnonymousClass anonymousClass = PsiTreeUtil.getParentOfType(element, PsiAnonymousClass.class); LOG.assertTrue(anonymousClass != null); - + ChangeContextUtil.encodeContextInfo(anonymousClass, true); boolean validContext = LambdaUtil.isValidLambdaContext(anonymousClass.getParent().getParent()); final String canonicalText = anonymousClass.getBaseClassType().getCanonicalText(); final PsiMethod method = anonymousClass.getMethods()[0]; @@ -139,25 +137,69 @@ public class AnonymousCanBeLambdaInspection extends BaseJavaLocalInspectionTool final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); PsiLambdaExpression lambdaExpression = (PsiLambdaExpression)elementFactory.createExpressionFromText(withoutTypesDeclared, anonymousClass); + + final PsiCodeBlock body = method.getBody(); + LOG.assertTrue(body != null); + final PsiStatement[] statements = body.getStatements(); + PsiElement copy = body.copy(); + if (statements.length == 1 && statements[0] instanceof PsiReturnStatement) { + PsiExpression value = ((PsiReturnStatement)statements[0]).getReturnValue(); + if (value != null) { + copy = value.copy(); + } + } + + PsiElement lambdaBody = lambdaExpression.getBody(); + LOG.assertTrue(lambdaBody != null); + lambdaBody.replace(copy); + final PsiNewExpression newExpression = (PsiNewExpression)anonymousClass.getParent(); lambdaExpression = (PsiLambdaExpression)newExpression.replace(lambdaExpression); + ChangeContextUtil.decodeContextInfo(lambdaExpression, null, null); if (!validContext) { - lambdaExpression.replace(elementFactory.createExpressionFromText("((" + canonicalText + ")" + withoutTypesDeclared + ")", lambdaExpression)); + final PsiParenthesizedExpression typeCast = + (PsiParenthesizedExpression)elementFactory.createExpressionFromText("((" + canonicalText + ")" + withoutTypesDeclared + ")", lambdaExpression); + final PsiExpression typeCastExpr = typeCast.getExpression(); + LOG.assertTrue(typeCastExpr != null); + final PsiExpression typeCastOperand = ((PsiTypeCastExpression)typeCastExpr).getOperand(); + LOG.assertTrue(typeCastOperand != null); + final PsiElement fromText = ((PsiLambdaExpression)typeCastOperand).getBody(); + LOG.assertTrue(fromText != null); + lambdaBody = lambdaExpression.getBody(); + LOG.assertTrue(lambdaBody != null); + fromText.replace(lambdaBody); + lambdaExpression.replace(typeCast); return; } + PsiType interfaceType = lambdaExpression.getFunctionalInterfaceType(); - if (isInferenced(lambdaExpression, interfaceType)) { - lambdaExpression = (PsiLambdaExpression)lambdaExpression.replace(elementFactory.createExpressionFromText(lambdaWithTypesDeclared, lambdaExpression)); + if (isInferred(lambdaExpression, interfaceType)) { + final PsiLambdaExpression withTypes = + (PsiLambdaExpression)elementFactory.createExpressionFromText(lambdaWithTypesDeclared, lambdaExpression); + final PsiElement withTypesBody = withTypes.getBody(); + LOG.assertTrue(withTypesBody != null); + lambdaBody = lambdaExpression.getBody(); + LOG.assertTrue(lambdaBody != null); + withTypesBody.replace(lambdaBody); + lambdaExpression = (PsiLambdaExpression)lambdaExpression.replace(withTypes); interfaceType = lambdaExpression.getFunctionalInterfaceType(); - if (isInferenced(lambdaExpression, interfaceType)) { - lambdaExpression.replace(elementFactory.createExpressionFromText("(" + canonicalText + ")" + withoutTypesDeclared, lambdaExpression)); + if (isInferred(lambdaExpression, interfaceType)) { + final PsiTypeCastExpression typeCast = (PsiTypeCastExpression)elementFactory.createExpressionFromText("(" + canonicalText + ")" + withoutTypesDeclared, lambdaExpression); + final PsiExpression typeCastOperand = typeCast.getOperand(); + LOG.assertTrue(typeCastOperand instanceof PsiLambdaExpression); + final PsiElement fromText = ((PsiLambdaExpression)typeCastOperand).getBody(); + LOG.assertTrue(fromText != null); + lambdaBody = lambdaExpression.getBody(); + LOG.assertTrue(lambdaBody != null); + fromText.replace(lambdaBody); + lambdaExpression.replace(typeCast); } } } } - private static boolean isInferenced(PsiLambdaExpression lambdaExpression, PsiType interfaceType) { + private static boolean isInferred(PsiLambdaExpression lambdaExpression, PsiType interfaceType) { return interfaceType == null || !LambdaUtil.isLambdaFullyInferred(lambdaExpression, interfaceType) || LambdaUtil.checkInterfaceFunctional(interfaceType) != null; } @@ -185,18 +227,7 @@ public class AnonymousCanBeLambdaInspection extends BaseJavaLocalInspectionTool buf.append(")"); } } - buf.append("->"); - final PsiCodeBlock body = method.getBody(); - LOG.assertTrue(body != null); - final PsiStatement[] statements = body.getStatements(); - if (statements.length == 1 && statements[0] instanceof PsiReturnStatement) { - PsiExpression value = ((PsiReturnStatement)statements[0]).getReturnValue(); - if (value != null) { - buf.append(value.getText()); - return buf.toString(); - } - } - buf.append(body.getText()); + buf.append("-> {}"); return buf.toString(); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java index 14128b82d518..fb452bc2790f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java @@ -2,13 +2,13 @@ class Test { { Comparable c = o -> { - Runnable r = new Runnable() { - @Override - public void run() { - System.out.println(o); - } - }; - return 0; + Runnable r = new Runnable() { + @Override + public void run() { + System.out.println(o); + } + }; + return 0; }; } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterMultilineComparable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterMultilineComparable.java index 4feda0438041..4c653e673b3a 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterMultilineComparable.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterMultilineComparable.java @@ -2,8 +2,8 @@ class Test { { Comparable c = o -> { - System.out.println(); - return 0; + System.out.println(); + return 0; }; } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterNeedToQualifyAccess.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterNeedToQualifyAccess.java new file mode 100644 index 000000000000..050c310cf187 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterNeedToQualifyAccess.java @@ -0,0 +1,16 @@ +// "Replace with lambda" "true" +class Test { + interface I { + + } + interface Bar extends I { + int smth = 0; + int compare(String o1, String o2); + } + { + I bar2 = (Bar) (o1, o2) -> { + System.out.println(Bar.smth); + return 0; + }; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java index e361f202ca4f..8860a7ce35d6 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java @@ -2,7 +2,7 @@ class Test { { Runnable r = () -> { - System.out.println(""); + System.out.println(""); }; } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java index 61172027433a..0688e8bbee46 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java @@ -2,7 +2,7 @@ class Test { { Runnable[] r = new Runnable[] {() -> { - System.out.println(""); + System.out.println(""); }}; } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFieldInAnonymous.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFieldInAnonymous.java new file mode 100644 index 000000000000..3dc51915fb2d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeFieldInAnonymous.java @@ -0,0 +1,18 @@ +// "Replace with lambda" "false" +class Test { + interface I { + + } + interface Bar extends I { + int compare(String o1, String o2); + } + { + I bar2 = new Bar() { + int k; + @Override + public int compare(String o1, String o2) { + return 0; + } + }; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNeedToQualifyAccess.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNeedToQualifyAccess.java new file mode 100644 index 000000000000..b6de9163aa35 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeNeedToQualifyAccess.java @@ -0,0 +1,19 @@ +// "Replace with lambda" "true" +class Test { + interface I { + + } + interface Bar extends I { + int smth = 0; + int compare(String o1, String o2); + } + { + I bar2 = new Bar() { + @Override + public int compare(String o1, String o2) { + System.out.println(smth); + return 0; + } + }; + } +} \ No newline at end of file