diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java index 4dacb84d0469..4eb3a33b83e9 100644 --- a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java +++ b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2013 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. @@ -34,12 +34,8 @@ import com.intellij.openapi.util.TextRange; import com.intellij.pom.Navigatable; import com.intellij.psi.*; import com.intellij.psi.presentation.java.ClassPresentationUtil; -import com.intellij.psi.util.PsiFormatUtil; -import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.psi.util.PsiUtilBase; -import com.intellij.psi.util.PsiUtilCore; +import com.intellij.psi.util.*; import com.intellij.ui.LayeredIcon; -import com.intellij.psi.util.FileTypeUtils; import org.jetbrains.annotations.NotNull; import javax.swing.*; @@ -68,7 +64,7 @@ public final class CallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i return myElement == null ? null : getEnclosingElement(myElement); } - static PsiMember getEnclosingElement(final PsiElement element){ + public static PsiMember getEnclosingElement(final PsiElement element){ return PsiTreeUtil.getNonStrictParentOfType(element, PsiMethod.class, PsiClass.class); } @@ -138,8 +134,8 @@ public final class CallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i } final String methodText = PsiFormatUtil.formatMethod( method, - PsiSubstitutor.EMPTY, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_PARAMETERS, - PsiFormatUtil.SHOW_TYPE + PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, + PsiFormatUtilBase.SHOW_TYPE ); buffer.append(methodText); diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallerMethodsTreeStructure.java b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallerMethodsTreeStructure.java index 5699d335c28e..45363bbef95f 100644 --- a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallerMethodsTreeStructure.java +++ b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallerMethodsTreeStructure.java @@ -17,12 +17,11 @@ package com.intellij.ide.hierarchy.call; import com.intellij.ide.hierarchy.HierarchyNodeDescriptor; import com.intellij.ide.hierarchy.HierarchyTreeStructure; +import com.intellij.ide.util.treeView.NodeDescriptor; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.search.SearchScope; import com.intellij.psi.search.searches.MethodReferencesSearch; -import com.intellij.psi.util.PsiUtil; -import com.intellij.psi.util.TypeConversionUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.Processor; import com.intellij.util.containers.ContainerUtil; @@ -63,69 +62,15 @@ public final class CallerMethodsTreeStructure extends HierarchyTreeStructure { methodsToFind.add(method); ContainerUtil.addAll(methodsToFind, method.findDeepestSuperMethods()); - final Map methodToDescriptorMap = new HashMap(); + final Map methodToDescriptorMap = new HashMap(); for (final PsiMethod methodToFind : methodsToFind) { + final JavaCallHierarchyData data = new JavaCallHierarchyData(originalClass, methodToFind, originalType, method, methodsToFind, descriptor, methodToDescriptorMap, myProject); + MethodReferencesSearch.search(methodToFind, searchScope, true).forEach(new Processor() { @Override public boolean process(final PsiReference reference) { - if (reference instanceof PsiReferenceExpression) { - final PsiExpression qualifier = ((PsiReferenceExpression)reference).getQualifierExpression(); - if (qualifier instanceof PsiSuperExpression) { // filter super.foo() call inside foo() and similar cases (bug 8411) - final PsiClass superClass = PsiUtil.resolveClassInType(qualifier.getType()); - if (originalClass.isInheritor(superClass, true)) { - return true; - } - } - if (qualifier != null && !methodToFind.hasModifierProperty(PsiModifier.STATIC)) { - final PsiType qualifierType = qualifier.getType(); - if (qualifierType instanceof PsiClassType && - !TypeConversionUtil.isAssignable(qualifierType, originalType) && - methodToFind != method) { - final PsiClass psiClass = ((PsiClassType)qualifierType).resolve(); - if (psiClass != null) { - final PsiMethod callee = psiClass.findMethodBySignature(methodToFind, true); - if (callee != null && !methodsToFind.contains(callee)) { - // skip sibling methods - return true; - } - } - } - } - } - else { - if (!(reference instanceof PsiElement)) { - return true; - } - - final PsiElement parent = ((PsiElement)reference).getParent(); - if (parent instanceof PsiNewExpression) { - if (((PsiNewExpression)parent).getClassReference() != reference) { - return true; - } - } - else if (parent instanceof PsiAnonymousClass) { - if (((PsiAnonymousClass)parent).getBaseClassReference() != reference) { - return true; - } - } - else { - return true; - } - } - - final PsiElement element = reference.getElement(); - final PsiMember key = CallHierarchyNodeDescriptor.getEnclosingElement(element); - - synchronized (methodToDescriptorMap) { - CallHierarchyNodeDescriptor d = methodToDescriptorMap.get(key); - if (d == null) { - d = new CallHierarchyNodeDescriptor(myProject, descriptor, element, false, true); - methodToDescriptorMap.put(key, d); - } - else if (!d.hasReference(reference)) { - d.incrementUsageCount(); - } - d.addReference(reference); + for (CallReferenceProcessor processor : CallReferenceProcessor.EP_NAME.getExtensions()) { + if (!processor.process(reference, data)) break; } return true; } diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/call/JavaCallReferenceProcessor.java b/java/java-impl/src/com/intellij/ide/hierarchy/call/JavaCallReferenceProcessor.java new file mode 100644 index 000000000000..e563ee64381f --- /dev/null +++ b/java/java-impl/src/com/intellij/ide/hierarchy/call/JavaCallReferenceProcessor.java @@ -0,0 +1,103 @@ +/* + * Copyright 2000-2013 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.ide.hierarchy.call; + +import com.intellij.ide.util.treeView.NodeDescriptor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.*; +import com.intellij.psi.util.PsiUtil; +import com.intellij.psi.util.TypeConversionUtil; +import org.jetbrains.annotations.NotNull; + +import java.util.Map; +import java.util.Set; + +/** + * Created by Max Medvedev on 10/5/13 + */ +public class JavaCallReferenceProcessor implements CallReferenceProcessor { + @Override + public boolean process(@NotNull PsiReference reference, @NotNull JavaCallHierarchyData data) { + PsiClass originalClass = data.getOriginalClass(); + PsiMethod method = data.getMethod(); + Set methodsToFind = data.getMethodsToFind(); + PsiMethod methodToFind = data.getMethodToFind(); + PsiClassType originalType = data.getOriginalType(); + Map methodToDescriptorMap = data.getResultMap(); + Project myProject = data.getProject(); + + if (reference instanceof PsiReferenceExpression) { + final PsiExpression qualifier = ((PsiReferenceExpression)reference).getQualifierExpression(); + if (qualifier instanceof PsiSuperExpression) { // filter super.foo() call inside foo() and similar cases (bug 8411) + final PsiClass superClass = PsiUtil.resolveClassInType(qualifier.getType()); + if (superClass == null || originalClass.isInheritor(superClass, true)) { + return true; + } + } + if (qualifier != null && !methodToFind.hasModifierProperty(PsiModifier.STATIC)) { + final PsiType qualifierType = qualifier.getType(); + if (qualifierType instanceof PsiClassType && + !TypeConversionUtil.isAssignable(qualifierType, originalType) && + methodToFind != method) { + final PsiClass psiClass = ((PsiClassType)qualifierType).resolve(); + if (psiClass != null) { + final PsiMethod callee = psiClass.findMethodBySignature(methodToFind, true); + if (callee != null && !methodsToFind.contains(callee)) { + // skip sibling methods + return true; + } + } + } + } + } + else { + if (!(reference instanceof PsiElement)) { + return true; + } + + final PsiElement parent = ((PsiElement)reference).getParent(); + if (parent instanceof PsiNewExpression) { + if (((PsiNewExpression)parent).getClassReference() != reference) { + return true; + } + } + else if (parent instanceof PsiAnonymousClass) { + if (((PsiAnonymousClass)parent).getBaseClassReference() != reference) { + return true; + } + } + else { + return true; + } + } + + final PsiElement element = reference.getElement(); + final PsiMember key = CallHierarchyNodeDescriptor.getEnclosingElement(element); + + synchronized (methodToDescriptorMap) { + CallHierarchyNodeDescriptor d = (CallHierarchyNodeDescriptor)methodToDescriptorMap.get(key); + if (d == null) { + d = new CallHierarchyNodeDescriptor(myProject, (CallHierarchyNodeDescriptor)data.getNodeDescriptor(), element, false, true); + methodToDescriptorMap.put(key, d); + } + else if (!d.hasReference(reference)) { + d.incrementUsageCount(); + } + d.addReference(reference); + } + return false; + } +} diff --git a/java/openapi/src/com/intellij/ide/hierarchy/call/CallReferenceProcessor.java b/java/openapi/src/com/intellij/ide/hierarchy/call/CallReferenceProcessor.java new file mode 100644 index 000000000000..5c2585f1ede0 --- /dev/null +++ b/java/openapi/src/com/intellij/ide/hierarchy/call/CallReferenceProcessor.java @@ -0,0 +1,35 @@ +/* + * Copyright 2000-2013 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.ide.hierarchy.call; + +import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.psi.PsiReference; +import org.jetbrains.annotations.NotNull; + +/** + * Created by Max Medvedev on 10/5/13 + */ +public interface CallReferenceProcessor { + ExtensionPointName EP_NAME = ExtensionPointName.create("com.intellij.hierarchy.referenceProcessor"); + + /** + * + * @param reference reference to process + * @param data settings to use while processing + * @return false if the reference is processed + */ + boolean process(@NotNull PsiReference reference, @NotNull JavaCallHierarchyData data); +} diff --git a/java/openapi/src/com/intellij/ide/hierarchy/call/JavaCallHierarchyData.java b/java/openapi/src/com/intellij/ide/hierarchy/call/JavaCallHierarchyData.java new file mode 100644 index 000000000000..e2b5a7a6e2d9 --- /dev/null +++ b/java/openapi/src/com/intellij/ide/hierarchy/call/JavaCallHierarchyData.java @@ -0,0 +1,91 @@ +/* + * Copyright 2000-2013 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.ide.hierarchy.call; + +import com.intellij.ide.util.treeView.NodeDescriptor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiMember; +import com.intellij.psi.PsiMethod; + +import java.util.Map; +import java.util.Set; + +/** + * Created by Max Medvedev on 10/5/13 + */ +public class JavaCallHierarchyData { + private final PsiClass myOriginalClass; + private final PsiMethod myMethodToFind; + private final PsiClassType myOriginalType; + private final PsiMethod myMethod; + private final Set myMethodsToFind; + private final NodeDescriptor myNodeDescriptor; + private final Map myResultMap; + private final Project myProject; + + public JavaCallHierarchyData(PsiClass originalClass, + PsiMethod methodToFind, + PsiClassType originalType, + PsiMethod method, + Set methodsToFind, + NodeDescriptor nodeDescriptor, + Map resultMap, + Project project) { + + myOriginalClass = originalClass; + myMethodToFind = methodToFind; + myOriginalType = originalType; + myMethod = method; + myMethodsToFind = methodsToFind; + myNodeDescriptor = nodeDescriptor; + myResultMap = resultMap; + myProject = project; + } + + public PsiClass getOriginalClass() { + return myOriginalClass; + } + + public PsiMethod getMethodToFind() { + return myMethodToFind; + } + + public PsiClassType getOriginalType() { + return myOriginalType; + } + + public PsiMethod getMethod() { + return myMethod; + } + + public Set getMethodsToFind() { + return myMethodsToFind; + } + + public NodeDescriptor getNodeDescriptor() { + return myNodeDescriptor; + } + + public Map getResultMap() { + return myResultMap; + } + + public Project getProject() { + return myProject; + } +} diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml index d835e4583898..580712f5f0d1 100644 --- a/plugins/groovy/src/META-INF/plugin.xml +++ b/plugins/groovy/src/META-INF/plugin.xml @@ -413,7 +413,8 @@ - + + @@ -1458,6 +1459,7 @@ + diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallHierarchyProvider.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallHierarchyProvider.java new file mode 100644 index 000000000000..f4caaee1d629 --- /dev/null +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallHierarchyProvider.java @@ -0,0 +1,24 @@ +/* + * Copyright 2000-2013 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.hierarchy.call; + +import com.intellij.ide.hierarchy.call.JavaCallHierarchyProvider; + +/** + * Created by Max Medvedev on 10/5/13 + */ +public class GrCallHierarchyProvider extends JavaCallHierarchyProvider { +} diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallReferenceProcessor.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallReferenceProcessor.java new file mode 100644 index 000000000000..2b60ae7ad72c --- /dev/null +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/hierarchy/call/GrCallReferenceProcessor.java @@ -0,0 +1,108 @@ +/* + * Copyright 2000-2013 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.hierarchy.call; + +import com.intellij.ide.hierarchy.call.CallHierarchyNodeDescriptor; +import com.intellij.ide.hierarchy.call.CallReferenceProcessor; +import com.intellij.ide.hierarchy.call.JavaCallHierarchyData; +import com.intellij.ide.util.treeView.NodeDescriptor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.*; +import com.intellij.psi.util.PsiUtil; +import com.intellij.psi.util.TypeConversionUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression; +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression; +import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrAnonymousClassDefinition; + +import java.util.Map; +import java.util.Set; + +/** + * Created by Max Medvedev on 10/5/13 + */ +public class GrCallReferenceProcessor implements CallReferenceProcessor { + @Override + public boolean process(@NotNull PsiReference reference, @NotNull JavaCallHierarchyData data) { + PsiClass originalClass = data.getOriginalClass(); + PsiMethod method = data.getMethod(); + Set methodsToFind = data.getMethodsToFind(); + PsiMethod methodToFind = data.getMethodToFind(); + PsiClassType originalType = data.getOriginalType(); + Map methodToDescriptorMap = data.getResultMap(); + Project project = data.getProject(); + + if (reference instanceof GrReferenceExpression) { + final GrExpression qualifier = ((GrReferenceExpression)reference).getQualifierExpression(); + if (org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isSuperReference(qualifier)) { // filter super.foo() call inside foo() and similar cases (bug 8411) + assert qualifier != null; + final PsiClass superClass = PsiUtil.resolveClassInType(qualifier.getType()); + if (originalClass == null || originalClass.isInheritor(superClass, true)) { + return true; + } + } + if (qualifier != null && !methodToFind.hasModifierProperty(PsiModifier.STATIC)) { + final PsiType qualifierType = qualifier.getType(); + if (qualifierType instanceof PsiClassType && !TypeConversionUtil.isAssignable(qualifierType, originalType) && methodToFind != method) { + final PsiClass psiClass = ((PsiClassType)qualifierType).resolve(); + if (psiClass != null) { + final PsiMethod callee = psiClass.findMethodBySignature(methodToFind, true); + if (callee != null && !methodsToFind.contains(callee)) { + // skip sibling methods + return true; + } + } + } + } + } + else { + if (!(reference instanceof PsiElement)) { + return true; + } + + final PsiElement parent = ((PsiElement)reference).getParent(); + if (parent instanceof PsiNewExpression) { + if (((PsiNewExpression)parent).getClassReference() != reference) { + return true; + } + } + else if (parent instanceof GrAnonymousClassDefinition) { + if (((GrAnonymousClassDefinition)parent).getBaseClassReferenceGroovy() != reference) { + return true; + } + } + else { + return true; + } + } + + final PsiElement element = reference.getElement(); + final PsiMember key = CallHierarchyNodeDescriptor.getEnclosingElement(element); + + synchronized (methodToDescriptorMap) { + CallHierarchyNodeDescriptor d = (CallHierarchyNodeDescriptor)methodToDescriptorMap.get(key); + if (d == null) { + d = new CallHierarchyNodeDescriptor(project, (CallHierarchyNodeDescriptor)data.getNodeDescriptor(), element, false, true); + methodToDescriptorMap.put(key, d); + } + else if (!d.hasReference(reference)) { + d.incrementUsageCount(); + } + d.addReference(reference); + } + return true; + } +} diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index 9cd01d039dfb..fcdb7aac8016 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -240,6 +240,8 @@ + + @@ -1485,8 +1487,6 @@ - -